org.apache.ignite

Interface Ignite

All Superinterfaces:

AutoCloseable

All Known Subinterfaces:

IgniteEx

All Known Implementing Classes:

IgniteKernal

public interface Ignite
extends AutoCloseable

Main entry-point for all Ignite APIs. You can obtain an instance of Ignite through Ignition.ignite(), or for named grids you can use Ignition.ignite(String). Note that you can have multiple instances of Ignite running in the same VM by giving each instance a different name.

Ignite provides the following functionality:

• IgniteCluster - clustering functionality.
• IgniteCache - functionality for in-memory distributed cache, including SQL, TEXT, and Predicate-based queries.
• IgniteTransactions - distributed ACID-compliant transactions.
• IgniteDataStreamer - functionality for streaming large amounts of data into cache.
• IgniteCompute - functionality for executing tasks and closures on all grid nodes (inherited form ClusterGroup).
• IgniteServices - distributed service grid functionality (e.g. singletons on the cluster).
• IgniteMessaging - functionality for topic-based message exchange on all grid nodes (inherited form ClusterGroup).
• IgniteEvents - functionality for querying and listening to events on all grid nodes (inherited form ClusterGroup).
• ExecutorService - distributed thread pools.
• IgniteAtomicLong - distributed atomic long.
• IgniteAtomicReference - distributed atomic reference.
• IgniteAtomicSequence - distributed atomic sequence.
• IgniteAtomicStamped - distributed atomic stamped reference.
• IgniteCountDownLatch - distributed count down latch.
• IgniteQueue - distributed blocking queue.
• IgniteSet - distributed concurrent set.
• IgniteScheduler - functionality for scheduling jobs using UNIX Cron syntax.
• IgniteFileSystem - functionality for distributed Hadoop-compliant in-memory file system and map-reduce.

Method Summary

Methods

Modifier and Type	Method and Description
<K,V> void	addCacheConfiguration(CacheConfiguration<K,V> cacheCfg) Adds cache configuration template.
<K> Affinity<K>	affinity(String cacheName) Gets affinity service to provide information about data partitioning and distribution.
IgniteAtomicLong	atomicLong(String name, long initVal, boolean create) Will get a atomic long from cache and create one if it has not been created yet and create flag is true.
<T> IgniteAtomicReference<T>	atomicReference(String name, T initVal, boolean create) Will get a atomic reference from cache and create one if it has not been created yet and create flag is true.
IgniteAtomicSequence	atomicSequence(String name, long initVal, boolean create) Will get an atomic sequence from cache and create one if it has not been created yet and create flag is true.
<T,S> IgniteAtomicStamped<T,S>	atomicStamped(String name, T initVal, S initStamp, boolean create) Will get a atomic stamped from cache and create one if it has not been created yet and create flag is true.
IgniteBinary	binary() Gets an instance of IgniteBinary interface.
<K,V> IgniteCache<K,V>	cache(String name) Gets an instance of IgniteCache API.
Collection<String>	cacheNames() Gets the collection of names of currently available caches.
void	close() Closes this instance of grid.
IgniteCluster	cluster() Gets an instance of IgniteCluster interface.
IgniteCompute	compute() Gets compute facade over all cluster nodes started in server mode.
IgniteCompute	compute(ClusterGroup grp) Gets compute facade over the specified cluster group.
IgniteConfiguration	configuration() Gets the configuration of this grid instance.
IgniteCountDownLatch	countDownLatch(String name, int cnt, boolean autoDel, boolean create) Gets or creates count down latch.
<K,V> IgniteCache<K,V>	createCache(CacheConfiguration<K,V> cacheCfg) Dynamically starts new cache with the given cache configuration.
<K,V> IgniteCache<K,V>	createCache(CacheConfiguration<K,V> cacheCfg, NearCacheConfiguration<K,V> nearCfg) Dynamically starts new cache with the given cache configuration.
<K,V> IgniteCache<K,V>	createCache(String cacheName) Dynamically starts new cache using template configuration.
<K,V> IgniteCache<K,V>	createNearCache(String cacheName, NearCacheConfiguration<K,V> nearCfg) Starts a near cache on local node if cache was previously started with one of the createCache(CacheConfiguration) or createCache(CacheConfiguration, NearCacheConfiguration) methods.
<K,V> IgniteDataStreamer<K,V>	dataStreamer(String cacheName) Gets a new instance of data streamer associated with given cache name.
void	destroyCache(String cacheName) Stops dynamically started cache.
IgniteEvents	events() Gets events facade over all cluster nodes.
IgniteEvents	events(ClusterGroup grp) Gets events facade over nodes within the cluster group.
ExecutorService	executorService() Creates a new ExecutorService which will execute all submitted Callable and Runnable jobs on all cluster nodes.
ExecutorService	executorService(ClusterGroup grp) Creates a new ExecutorService which will execute all submitted Callable and Runnable jobs on nodes in the specified cluster group.
IgniteFileSystem	fileSystem(String name) Gets an instance of IGFS (Ignite In-Memory File System).
Collection<IgniteFileSystem>	fileSystems() Gets all instances of IGFS (Ignite In-Memory File System).
<K,V> IgniteCache<K,V>	getOrCreateCache(CacheConfiguration<K,V> cacheCfg) Gets existing cache with the given name or creates new one with the given configuration.
<K,V> IgniteCache<K,V>	getOrCreateCache(CacheConfiguration<K,V> cacheCfg, NearCacheConfiguration<K,V> nearCfg) Gets existing cache with the given cache configuration or creates one if it does not exist.
<K,V> IgniteCache<K,V>	getOrCreateCache(String cacheName) Gets existing cache with the given name or creates new one using template configuration.
<K,V> IgniteCache<K,V>	getOrCreateNearCache(String cacheName, NearCacheConfiguration<K,V> nearCfg) Gets existing near cache with the given name or creates a new one.
IgniteLogger	log() Gets grid's logger.
IgniteMessaging	message() Gets messaging facade over all cluster nodes.
IgniteMessaging	message(ClusterGroup grp) Gets messaging facade over nodes within the cluster group.
String	name() Gets the name of the grid this grid instance (and correspondingly its local node) belongs to.
<T extends IgnitePlugin> T	plugin(String name) Gets an instance of deployed Ignite plugin.
<T> IgniteQueue<T>	queue(String name, int cap, CollectionConfiguration cfg) Will get a named queue from cache and create one if it has not been created yet and cfg is not null.
IgniteScheduler	scheduler() Gets an instance of cron-based scheduler.
IgniteSemaphore	semaphore(String name, int cnt, boolean failoverSafe, boolean create) Gets or creates semaphore.
IgniteServices	services() Gets services facade over all cluster nodes started in server mode.
IgniteServices	services(ClusterGroup grp) Gets services facade over nodes within the cluster group.
<T> IgniteSet<T>	set(String name, CollectionConfiguration cfg) Will get a named set from cache and create one if it has not been created yet and cfg is not null.
IgniteTransactions	transactions() Gets grid transactions facade.
IgniteProductVersion	version() Gets Ignite version.

Method Detail

name

String name()

Gets the name of the grid this grid instance (and correspondingly its local node) belongs to. Note that single Java VM can have multiple grid instances all belonging to different grids. Grid name allows to indicate to what grid this particular grid instance (i.e. grid runtime and its local node) belongs to.

If default grid instance is used, then null is returned. Refer to Ignition documentation for information on how to start named grids.

Returns:

Name of the grid, or null for default grid.

log

IgniteLogger log()

Gets grid's logger.

Returns:

Grid's logger.

configuration

IgniteConfiguration configuration()

Gets the configuration of this grid instance.

NOTE:
SPIs obtains through this method should never be used directly. SPIs provide internal view on the subsystem and is used internally by Ignite kernal. In rare use cases when access to a specific implementation of this SPI is required - an instance of this SPI can be obtained via this method to check its configuration properties or call other non-SPI methods.

Returns:

Grid configuration instance.

cluster

IgniteCluster cluster()

Gets an instance of IgniteCluster interface.

Returns:

Instance of IgniteCluster interface.

compute

IgniteCompute compute()

Gets compute facade over all cluster nodes started in server mode.

Returns:

Compute instance over all cluster nodes started in server mode.

compute

IgniteCompute compute(ClusterGroup grp)

Gets compute facade over the specified cluster group. All operations on the returned IgniteCompute instance will only include nodes from this cluster group.

Parameters:

grp - Cluster group.

Returns:

Compute instance over given cluster group.

message

IgniteMessaging message()

Gets messaging facade over all cluster nodes.

Returns:

Messaging instance over all cluster nodes.

message

IgniteMessaging message(ClusterGroup grp)

Gets messaging facade over nodes within the cluster group. All operations on the returned IgniteMessaging instance will only include nodes from the specified cluster group.

Parameters:

grp - Cluster group.

Returns:

Messaging instance over given cluster group.

events

IgniteEvents events()

Gets events facade over all cluster nodes.

Returns:

Events instance over all cluster nodes.

events

IgniteEvents events(ClusterGroup grp)

Gets events facade over nodes within the cluster group. All operations on the returned IgniteEvents instance will only include nodes from the specified cluster group.

Parameters:

grp - Cluster group.

Returns:

Events instance over given cluster group.

services

IgniteServices services()

Gets services facade over all cluster nodes started in server mode.

Returns:

Services facade over all cluster nodes started in server mode.

services

IgniteServices services(ClusterGroup grp)

Gets services facade over nodes within the cluster group. All operations on the returned IgniteMessaging instance will only include nodes from the specified cluster group.

Parameters:

grp - Cluster group.

Returns:

Services functionality over given cluster group.

executorService

ExecutorService executorService()

Creates a new ExecutorService which will execute all submitted Callable and Runnable jobs on all cluster nodes. This essentially creates a Distributed Thread Pool that can be used as a replacement for local thread pools.

Returns:

Grid-enabled ExecutorService.

executorService

ExecutorService executorService(ClusterGroup grp)

Creates a new ExecutorService which will execute all submitted Callable and Runnable jobs on nodes in the specified cluster group. This essentially creates a Distributed Thread Pool that can be used as a replacement for local thread pools.

Parameters:

grp - Cluster group.

Returns:

ExecutorService which will execute jobs on nodes in given cluster group.

version

IgniteProductVersion version()

Gets Ignite version.

Returns:

Ignite version.

scheduler

IgniteScheduler scheduler()

Gets an instance of cron-based scheduler.

Returns:

Instance of scheduler.

createCache

<K,V> IgniteCache<K,V> createCache(CacheConfiguration<K,V> cacheCfg)

Dynamically starts new cache with the given cache configuration.

If local node is an affinity node, this method will return the instance of started cache. Otherwise, it will create a client cache on local node.

If a cache with the same name already exists in the grid, an exception will be thrown regardless whether the given configuration matches the configuration of the existing cache or not.

Parameters:

cacheCfg - Cache configuration to use.

Returns:

Instance of started cache.

createCache

<K,V> IgniteCache<K,V> createCache(String cacheName)

Dynamically starts new cache using template configuration.

If local node is an affinity node, this method will return the instance of started cache. Otherwise, it will create a client cache on local node.

If a cache with the same name already exists in the grid, an exception will be thrown.

Parameters:

cacheName - Cache name.

Returns:

Instance of started cache.

getOrCreateCache

<K,V> IgniteCache<K,V> getOrCreateCache(CacheConfiguration<K,V> cacheCfg)

Gets existing cache with the given name or creates new one with the given configuration.

If a cache with the same name already exist, this method will not check that the given configuration matches the configuration of existing cache and will return an instance of the existing cache.

Parameters:

cacheCfg - Cache configuration to use.

Returns:

Existing or newly created cache.

getOrCreateCache

<K,V> IgniteCache<K,V> getOrCreateCache(String cacheName)

Gets existing cache with the given name or creates new one using template configuration.

Parameters:

cacheName - Cache name.

Returns:

Existing or newly created cache.

addCacheConfiguration

<K,V> void addCacheConfiguration(CacheConfiguration<K,V> cacheCfg)

Adds cache configuration template.

Parameters:

cacheCfg - Cache configuration template.

createCache

<K,V> IgniteCache<K,V> createCache(CacheConfiguration<K,V> cacheCfg,
                                 NearCacheConfiguration<K,V> nearCfg)

Dynamically starts new cache with the given cache configuration.

If local node is an affinity node, this method will return the instance of started cache. Otherwise, it will create a near cache with the given configuration on local node.

If a cache with the same name already exists in the grid, an exception will be thrown regardless whether the given configuration matches the configuration of the existing cache or not.

Parameters:

cacheCfg - Cache configuration to use.

nearCfg - Near cache configuration to use on local node in case it is not an affinity node.

Returns:

Instance of started cache.

getOrCreateCache

<K,V> IgniteCache<K,V> getOrCreateCache(CacheConfiguration<K,V> cacheCfg,
                                      NearCacheConfiguration<K,V> nearCfg)

Gets existing cache with the given cache configuration or creates one if it does not exist.

If a cache with the same name already exist, this method will not check that the given configuration matches the configuration of existing cache and will return an instance of the existing cache.

If local node is not an affinity node and a client cache without near cache has been already started on this node, an exception will be thrown.

Parameters:

cacheCfg - Cache configuration.

nearCfg - Near cache configuration for client.

Returns:

IgniteCache instance.

createNearCache

<K,V> IgniteCache<K,V> createNearCache(@Nullable
                                     String cacheName,
                                     NearCacheConfiguration<K,V> nearCfg)

Starts a near cache on local node if cache was previously started with one of the createCache(CacheConfiguration) or createCache(CacheConfiguration, NearCacheConfiguration) methods.

Parameters:

cacheName - Cache name.

nearCfg - Near cache configuration.

Returns:

Cache instance.

getOrCreateNearCache

<K,V> IgniteCache<K,V> getOrCreateNearCache(@Nullable
                                          String cacheName,
                                          NearCacheConfiguration<K,V> nearCfg)

Gets existing near cache with the given name or creates a new one.

Parameters:

cacheName - Cache name.

nearCfg - Near configuration.

Returns:

IgniteCache instance.

destroyCache

void destroyCache(String cacheName)

Stops dynamically started cache.

Parameters:

cacheName - Cache name to stop.

cache

<K,V> IgniteCache<K,V> cache(@Nullable
                           String name)

Gets an instance of IgniteCache API. IgniteCache is a fully-compatible implementation of JCache (JSR 107) specification.

Parameters:

name - Cache name.

Returns:

Instance of the cache for the specified name.

cacheNames

Collection<String> cacheNames()

Gets the collection of names of currently available caches. Collection may contain null as a value for a cache name. Refer to CacheConfiguration.getName() for more info.

Returns:

Collection of names of currently available caches or an empty collection if no caches are available.

transactions

IgniteTransactions transactions()

Gets grid transactions facade.

Returns:

Grid transactions facade.

dataStreamer

<K,V> IgniteDataStreamer<K,V> dataStreamer(@Nullable
                                         String cacheName)

Gets a new instance of data streamer associated with given cache name. Data streamer is responsible for loading external data into in-memory data grid. For more information refer to IgniteDataStreamer documentation.

Parameters:

cacheName - Cache name (null for default cache).

Returns:

Data streamer.

fileSystem

IgniteFileSystem fileSystem(String name)

Gets an instance of IGFS (Ignite In-Memory File System). If one is not configured then IllegalArgumentException will be thrown.

IGFS is fully compliant with Hadoop FileSystem APIs and can be plugged into Hadoop installations. For more information refer to documentation on Hadoop integration shipped with Ignite.

Parameters:

name - IGFS name.

Returns:

IGFS instance.

Throws:

IllegalArgumentException - If IGFS with such name is not configured.

fileSystems

Collection<IgniteFileSystem> fileSystems()

Gets all instances of IGFS (Ignite In-Memory File System).

Returns:

Collection of IGFS instances.

atomicSequence

IgniteAtomicSequence atomicSequence(String name,
                                  long initVal,
                                  boolean create)
                                    throws IgniteException

Will get an atomic sequence from cache and create one if it has not been created yet and create flag is true.

Parameters:

name - Sequence name.

initVal - Initial value for sequence. Ignored if create flag is false.

create - Boolean flag indicating whether data structure should be created if does not exist.

Returns:

Sequence for the given name.

Throws:

IgniteException - If sequence could not be fetched or created.

atomicLong

IgniteAtomicLong atomicLong(String name,
                          long initVal,
                          boolean create)
                            throws IgniteException

Will get a atomic long from cache and create one if it has not been created yet and create flag is true.

Parameters:

name - Name of atomic long.

initVal - Initial value for atomic long. Ignored if create flag is false.

create - Boolean flag indicating whether data structure should be created if does not exist.

Returns:

Atomic long.

Throws:

IgniteException - If atomic long could not be fetched or created.

atomicReference

<T> IgniteAtomicReference<T> atomicReference(String name,
                                           @Nullable
                                           T initVal,
                                           boolean create)
                                         throws IgniteException

Will get a atomic reference from cache and create one if it has not been created yet and create flag is true.

Parameters:

name - Atomic reference name.

initVal - Initial value for atomic reference. Ignored if create flag is false.

create - Boolean flag indicating whether data structure should be created if does not exist.

Returns:

Atomic reference for the given name.

Throws:

IgniteException - If atomic reference could not be fetched or created.

atomicStamped

<T,S> IgniteAtomicStamped<T,S> atomicStamped(String name,
                                           @Nullable
                                           T initVal,
                                           @Nullable
                                           S initStamp,
                                           boolean create)
                                       throws IgniteException

Will get a atomic stamped from cache and create one if it has not been created yet and create flag is true.

Parameters:

name - Atomic stamped name.

initVal - Initial value for atomic stamped. Ignored if create flag is false.

initStamp - Initial stamp for atomic stamped. Ignored if create flag is false.

create - Boolean flag indicating whether data structure should be created if does not exist.

Returns:

Atomic stamped for the given name.

Throws:

IgniteException - If atomic stamped could not be fetched or created.

countDownLatch

IgniteCountDownLatch countDownLatch(String name,
                                  int cnt,
                                  boolean autoDel,
                                  boolean create)
                                    throws IgniteException

Gets or creates count down latch. If count down latch is not found in cache and create flag is true, it is created using provided name and count parameter.

Parameters:

name - Name of the latch.

cnt - Count for new latch creation. Ignored if create flag is false.

autoDel - True to automatically delete latch from cache when its count reaches zero. Ignored if create flag is false.

create - Boolean flag indicating whether data structure should be created if does not exist.

Returns:

Count down latch for the given name.

Throws:

IgniteException - If latch could not be fetched or created.

semaphore

IgniteSemaphore semaphore(String name,
                        int cnt,
                        boolean failoverSafe,
                        boolean create)
                          throws IgniteException

Gets or creates semaphore. If semaphore is not found in cache and create flag is true, it is created using provided name and count parameter.

Parameters:

name - Name of the semaphore.

cnt - Count for new semaphore creation. Ignored if create flag is false.

failoverSafe - True to create failover safe semaphore which means that if any node leaves topology permits already acquired by that node are silently released and become available for alive nodes to acquire. If flag is false then all threads waiting for available permits get interrupted.

create - Boolean flag indicating whether data structure should be created if does not exist.

Returns:

Semaphore for the given name.

Throws:

IgniteException - If semaphore could not be fetched or created.

queue

<T> IgniteQueue<T> queue(String name,
                       int cap,
                       @Nullable
                       CollectionConfiguration cfg)
                     throws IgniteException

Will get a named queue from cache and create one if it has not been created yet and cfg is not null. If queue is present already, queue properties will not be changed. Use collocation for CacheMode.PARTITIONED caches if you have lots of relatively small queues as it will make fetching, querying, and iteration a lot faster. If you have few very large queues, then you should consider turning off collocation as they simply may not fit in a single node's memory.

Parameters:

name - Name of queue.

cap - Capacity of queue, 0 for unbounded queue. Ignored if cfg is null.

cfg - Queue configuration if new queue should be created.

Returns:

Queue with given properties.

Throws:

IgniteException - If queue could not be fetched or created.

set

<T> IgniteSet<T> set(String name,
                   @Nullable
                   CollectionConfiguration cfg)
                 throws IgniteException

Will get a named set from cache and create one if it has not been created yet and cfg is not null.

Parameters:

name - Set name.

cfg - Set configuration if new set should be created.

Returns:

Set with given properties.

Throws:

IgniteException - If set could not be fetched or created.

plugin

<T extends IgnitePlugin> T plugin(String name)
                              throws PluginNotFoundException

Gets an instance of deployed Ignite plugin.

Type Parameters:

T - Plugin type.

Parameters:

name - Plugin name.

Returns:

Plugin instance.

Throws:

PluginNotFoundException - If plugin for the given name was not found.

binary

IgniteBinary binary()

Gets an instance of IgniteBinary interface.

Returns:

Instance of IgniteBinary interface.

close

void close()
           throws IgniteException

Closes this instance of grid. This method is identical to calling G.stop(gridName, true).

The method is invoked automatically on objects managed by the try-with-resources statement.

Specified by:

close in interface AutoCloseable

Throws:

IgniteException - If failed to stop grid.

affinity

<K> Affinity<K> affinity(String cacheName)

Gets affinity service to provide information about data partitioning and distribution.

Type Parameters:

K - Cache key type.

Parameters:

cacheName - Cache name.

Returns:

Affinity.