org.apache.ignite.internal

## Class IgniteKernal

- java.lang.Object
- - org.apache.ignite.internal.IgniteKernal

All Implemented Interfaces:
  Externalizable, Serializable, AutoCloseable, Ignite, IgniteEx, IgniteMXBean

    public class IgniteKernal
    extends Object
    implements IgniteEx, IgniteMXBean, Externalizable

Ignite kernal.

See http://en.wikipedia.org/wiki/Kernal for information on the misspelling.

See Also:
  Serialized Form

### Field Summary

Fields
`static String` `SITE` Ignite site that is shown in log messages.

### Constructor Summary

Constructors
Constructor and Description
`IgniteKernal()` No-arg constructor is required by externalization.
`IgniteKernal(GridSpringResourceContext rsrcCtx)`

### Method Summary

Methods
`boolean` `active()` Checks Ignite grid is active or not active.
`void` `active(boolean active)` Changes Ignite grid state to active or inactive.
`<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.
`boolean` `allEventsUserRecordable(int[] types)` Checks whether all provided events are user-recordable.
`IgniteAtomicLong` `atomicLong(String name, AtomicConfiguration cfg, 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`.
`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, AtomicConfiguration cfg, 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`.
`<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, AtomicConfiguration cfg, 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`.
`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, AtomicConfiguration cfg, 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`.
`<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.
`Collection<IgniteCacheProxy<?,?>>` `caches()`
`Collection<IgniteInternalCache<?,?>>` `cachesx(IgnitePredicate<? super IgniteInternalCache<?,?>>[] p)` Gets configured cache instance that satisfy all provided predicates including non-public caches.
`<K,V> IgniteInternalCache<K,V>` `cachex(String name)` Gets the cache instance for the given name if one is configured or `null` otherwise returning even non-public caches.
`void` `close()` Closes `this` instance of grid.
`IgniteClusterEx` `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 Ignite instance.
`GridKernalContext` `context()` It's intended for use by internal marshalling implementation only.
`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.
`Collection<IgniteCache>` `createCaches(Collection<CacheConfiguration> cacheCfgs)` Dynamically starts new caches with the given cache configurations.
`<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 `Ignite.createCache(CacheConfiguration)` or `Ignite.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.
`boolean` `destroyCache0(String cacheName, boolean sql)` Stops dynamically started cache.
`IgniteInternalFuture<Boolean>` `destroyCacheAsync(String cacheName, boolean sql, boolean checkThreadTx)`
`void` `destroyCaches(Collection<String> cacheNames)` Stops dynamically started caches.
`IgniteInternalFuture<?>` `destroyCachesAsync(Collection<String> cacheNames, boolean checkThreadTx)`
`void` `dumpDebugInfo()` Dumps debug information for the current node.
`IgniteEvents` `events()` Gets `events` facade over all cluster nodes.
`IgniteEvents` `events(ClusterGroup grp)` Gets `events` facade over nodes within the cluster group.
`boolean` `eventUserRecordable(int type)` Checks if the event type is user-recordable.
`String` `executeTask(String taskName, String arg)` A shortcut method that executes given task assuming single `java.lang.String` argument and `java.lang.String` return type.
`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> IgniteInternalCache<K,V>` `getCache(String name)`
`String` `getCheckpointSpiFormatted()` Gets a formatted instance of configured checkpoint SPI implementation.
`String` `getCollisionSpiFormatted()` Gets a formatted instance of configured collision SPI implementations.
`String` `getCommunicationSpiFormatted()` Gets a formatted instance of fully configured SPI communication implementation.
`String` `getCopyright()` Gets copyright statement for Ignite product.
`String` `getDeploymentSpiFormatted()` Gets a formatted instance of fully configured deployment SPI implementation.
`String` `getDiscoverySpiFormatted()` Gets a formatted instance of configured discovery SPI implementation.
`String` `getEventStorageSpiFormatted()` Gets a formatted instance of fully configured event SPI implementation.
`String` `getExecutorServiceFormatted()` Gets a formatted instance of fully configured thread pool that is used in grid.
`String` `getFailoverSpiFormatted()` Gets a formatted instance of fully configured failover SPI implementations.
`String` `getFullVersion()` Gets string presentation of the version.
`String` `getGridLoggerFormatted()` Gets a formatted instance of logger that is in grid.
`String` `getIgniteHome()` Gets Ignite installation home folder.
`String` `getInstanceName()` Gets optional kernal instance name.
`String` `getJdkInformation()` Gets JDK information.
`List<String>` `getLifecycleBeansFormatted()` Gets `toString()` representation of of lifecycle beans configured with Ignite.
`String` `getLoadBalancingSpiFormatted()` Gets a formatted instance of fully configured load balancing SPI implementations.
`UUID` `getLocalNodeId()` Unique identifier for this node within grid.
`String` `getMBeanServerFormatted()` Gets a formatted instance of MBean server instance.
`<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> IgniteBiTuple<IgniteCache<K,V>,Boolean>` `getOrCreateCache0(CacheConfiguration<K,V> cacheCfg, boolean sql)` Gets existing cache with the given name or creates new one with the given configuration.
`IgniteInternalFuture<?>` `getOrCreateCacheAsync(String cacheName, boolean checkThreadTx)`
`Collection<IgniteCache>` `getOrCreateCaches(Collection<CacheConfiguration> cacheCfgs)` Gets existing caches with the given name or created one with the given 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.
`String` `getOsInformation()` Gets OS information.
`String` `getOsUser()` Gets OS user.
`long` `getStartTimestamp()` Get start timestamp of the kernal.
`String` `getStartTimestampFormatted()` Gets string presentation of the kernal start timestamp.
`long` `getUpTime()` Gets up-time of the kernal.
`String` `getUpTimeFormatted()` Gets string presentation of up-time for the kernal.
`List<String>` `getUserAttributesFormatted()` Gets a list of formatted user-defined attributes added to this node.
`String` `getVmName()` Gets VM name.
`Hadoop` `hadoop()` Get Hadoop facade.
`IgniteFileSystem` `igfsx(String name)` Get IGFS instance returning null if it doesn't exist.
`<K,V> GridCacheAdapter<K,V>` `internalCache(String name)` USED ONLY FOR TESTING.
`boolean` `isJmxRemoteEnabled()` Whether or not remote JMX management is enabled for this node.
`boolean` `isPeerClassLoadingEnabled()` Returns `true` if peer class loading is enabled, `false` otherwise.
`boolean` `isRestartEnabled()` Whether or not node restart is enabled.
`boolean` `isStopping()`
`String` `latestVersion()` Get latest version in string form.
`ClusterNode` `localNode()` Gets local grid node.
`IgniteLogger` `log()` Gets grid's logger.
`Collection<MemoryMetrics>` `memoryMetrics()` Returns a collection of `MemoryMetrics` that reflects page memory usage on this Apache Ignite node instance.
`MemoryMetrics` `memoryMetrics(String memPlcName)` Returns the latest `MemoryMetrics` snapshot for the memory region of the given name.
`IgniteMessaging` `message()` Gets `messaging` facade over all cluster nodes.
`IgniteMessaging` `message(ClusterGroup prj)` Gets `messaging` facade over nodes within the cluster group.
`String` `name()` Gets the name of the Ignite instance.
`void` `onDisconnected()`
`void` `onReconnected(boolean clusterRestarted)`
`PersistenceMetrics` `persistentStoreMetrics()`
`boolean` `pingNode(String nodeId)` Pings node with given node ID to see whether it is alive.
`boolean` `pingNodeByAddress(String host)` Pings node with given host name to see if it is alive.
`<T extends IgnitePlugin> T` `plugin(String name)` Gets an instance of deployed Ignite plugin.
`void` `printLastErrors()` Prints errors.
`<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`.
`void` `readExternal(ObjectInput in)`
`protected Object` `readResolve()`
`IgniteLock` `reentrantLock(String name, boolean failoverSafe, boolean fair, boolean create)` Gets or creates reentrant lock.
`boolean` `removeCheckpoint(String key)` This method allows manually remove the checkpoint with given `key`.
`void` `resetLostPartitions(Collection<String> cacheNames)` Clears partition's lost state and moves caches to a normal mode.
`void` `runIoTest(long warmup, long duration, int threads, long maxLatency, int rangesCnt, int payLoadSize, boolean procFromNioThread)` Runs IO latency test against all remote server nodes in cluster.
`IgniteScheduler` `scheduler()` Gets an instance of cron-based scheduler.
`IgniteSemaphore` `semaphore(String name, int cnt, boolean failoverSafe, boolean create)` Gets or creates semaphore.
`IgniteInternalFuture` `sendIoTest(ClusterNode node, byte[] payload, boolean procFromNioThread)`
`IgniteInternalFuture` `sendIoTest(List<ClusterNode> nodes, byte[] payload, boolean procFromNioThread)`
`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`.

`void`

`start(IgniteConfiguration cfg, ExecutorService utilityCachePool, ExecutorService execSvc, ExecutorService svcExecSvc, ExecutorService sysExecSvc, StripedExecutor stripedExecSvc, ExecutorService p2pExecSvc, ExecutorService mgmtExecSvc, ExecutorService igfsExecSvc, ExecutorService dataStreamExecSvc, ExecutorService restExecSvc, ExecutorService affExecSvc, ExecutorService idxExecSvc, IgniteStripedThreadPoolExecutor callbackExecSvc, ExecutorService qryExecSvc, ExecutorService schemaExecSvc, Map<String,? extends ExecutorService> customExecSvcs, GridAbsClosure errHnd)`

`void` `stop(boolean cancel)` Stops grid instance.
`String` `toString()`
`IgniteTransactions` `transactions()` Gets grid transactions facade.
`void` `undeployTaskFromGrid(String taskName)` Makes the best attempt to undeploy a task from the whole grid.
`<K extends GridCacheUtilityKey,V> IgniteInternalCache<K,V>` `utilityCache()` Gets utility cache.
`IgniteProductVersion` `version()` Gets Ignite version.
`void` `writeExternal(ObjectOutput out)`

### Methods inherited from class java.lang.Object

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

### Field Detail

#### SITE

    public static final String SITE

Ignite site that is shown in log messages.

See Also:
  Constant Field Values

### Constructor Detail

#### IgniteKernal

    public IgniteKernal()

No-arg constructor is required by externalization.

#### IgniteKernal

    public IgniteKernal(@Nullable
                GridSpringResourceContext rsrcCtx)

Parameters:
  `rsrcCtx` - Optional Spring application context.

### Method Detail

#### cluster

    public IgniteClusterEx cluster()

Gets an instance of `IgniteCluster` interface.

Specified by:
  `cluster` in interface `Ignite`
Specified by:
  `cluster` in interface `IgniteEx`
Returns:
  Instance of `IgniteCluster` interface.

#### localNode

    public ClusterNode localNode()

Gets local grid node.

Specified by:
  `localNode` in interface `IgniteEx`
Returns:
  Local grid node.

#### compute

    public IgniteCompute compute()

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

Specified by:
  `compute` in interface `Ignite`
Returns:
  Compute instance over all cluster nodes started in server mode.

#### message

    public IgniteMessaging message()

Gets `messaging` facade over all cluster nodes.

Specified by:
  `message` in interface `Ignite`
Returns:
  Messaging instance over all cluster nodes.

#### events

    public IgniteEvents events()

Gets `events` facade over all cluster nodes.

Specified by:
  `events` in interface `Ignite`
Returns:
  Events instance over all cluster nodes.

#### services

    public IgniteServices services()

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

Specified by:
  `services` in interface `Ignite`
Returns:
  Services facade over all cluster nodes started in server mode.

#### executorService

    public 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.

Specified by:
  `executorService` in interface `Ignite`
Returns:
  Grid-enabled `ExecutorService`.

#### compute

    public final 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.

Specified by:
  `compute` in interface `Ignite`
Parameters:
  `grp` - Cluster group.
Returns:
  Compute instance over given cluster group.

#### message

    public final IgniteMessaging message(ClusterGroup prj)

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.

Specified by:
  `message` in interface `Ignite`
Parameters:
  `prj` - Cluster group.
Returns:
  Messaging instance over given cluster group.

#### events

    public final 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.

Specified by:
  `events` in interface `Ignite`
Parameters:
  `grp` - Cluster group.
Returns:
  Events instance over given cluster group.

#### services

    public 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.

Specified by:
  `services` in interface `Ignite`
Parameters:
  `grp` - Cluster group.
Returns:
  `Services` functionality over given cluster group.

#### executorService

    public 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.

Specified by:
  `executorService` in interface `Ignite`
Parameters:
  `grp` - Cluster group.
Returns:
  `ExecutorService` which will execute jobs on nodes in given cluster group.

#### name

    public String name()

Gets the name of the Ignite instance. The name allows having multiple Ignite instances with different names within the same Java VM.

If default Ignite instance is used, then `null` is returned. Refer to `Ignition` documentation for information on how to start named ignite Instances.

Specified by:
  `name` in interface `Ignite`
Returns:
  Name of the Ignite instance, or `null` for default Ignite instance.

#### getCopyright

    public String getCopyright()

Gets copyright statement for Ignite product.

Specified by:
  `getCopyright` in interface `IgniteMXBean`
Returns:
  Copyright statement for Ignite product.

#### getStartTimestamp

    public long getStartTimestamp()

Get start timestamp of the kernal.

Specified by:
  `getStartTimestamp` in interface `IgniteMXBean`
Returns:
  Start timestamp of the kernal.

#### getStartTimestampFormatted

    public String getStartTimestampFormatted()

Gets string presentation of the kernal start timestamp.

Specified by:
  `getStartTimestampFormatted` in interface `IgniteMXBean`
Returns:
  String presentation of the kernal start timestamp.

#### getUpTime

    public long getUpTime()

Gets up-time of the kernal.

Specified by:
  `getUpTime` in interface `IgniteMXBean`
Returns:
  Up-time of the kernal.

#### getUpTimeFormatted

    public String getUpTimeFormatted()

Gets string presentation of up-time for the kernal.

Specified by:
  `getUpTimeFormatted` in interface `IgniteMXBean`
Returns:
  String presentation of up-time for the kernal.

#### getFullVersion

    public String getFullVersion()

Gets string presentation of the version.

Specified by:
  `getFullVersion` in interface `IgniteMXBean`
Returns:
  String presentation of the version.

#### getCheckpointSpiFormatted

    public String getCheckpointSpiFormatted()

Gets a formatted instance of configured checkpoint SPI implementation.

Specified by:
  `getCheckpointSpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid checkpoint SPI implementation.

#### getCommunicationSpiFormatted

    public String getCommunicationSpiFormatted()

Gets a formatted instance of fully configured SPI communication implementation.

Specified by:
  `getCommunicationSpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid communication SPI implementation.

#### getDeploymentSpiFormatted

    public String getDeploymentSpiFormatted()

Gets a formatted instance of fully configured deployment SPI implementation.

Specified by:
  `getDeploymentSpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid deployment SPI implementation.

#### getDiscoverySpiFormatted

    public String getDiscoverySpiFormatted()

Gets a formatted instance of configured discovery SPI implementation.

Specified by:
  `getDiscoverySpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid discovery SPI implementation.

#### getEventStorageSpiFormatted

    public String getEventStorageSpiFormatted()

Gets a formatted instance of fully configured event SPI implementation.

Specified by:
  `getEventStorageSpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid event SPI implementation.

#### getCollisionSpiFormatted

    public String getCollisionSpiFormatted()

Gets a formatted instance of configured collision SPI implementations.

Specified by:
  `getCollisionSpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid collision SPI implementations.

#### getFailoverSpiFormatted

    public String getFailoverSpiFormatted()

Gets a formatted instance of fully configured failover SPI implementations.

Specified by:
  `getFailoverSpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid failover SPI implementations.

#### getLoadBalancingSpiFormatted

    public String getLoadBalancingSpiFormatted()

Gets a formatted instance of fully configured load balancing SPI implementations.

Specified by:
  `getLoadBalancingSpiFormatted` in interface `IgniteMXBean`
Returns:
  Grid load balancing SPI implementations.

#### getOsInformation

    public String getOsInformation()

Gets OS information.

Specified by:
  `getOsInformation` in interface `IgniteMXBean`
Returns:
  OS information.

#### getJdkInformation

    public String getJdkInformation()

Gets JDK information.

Specified by:
  `getJdkInformation` in interface `IgniteMXBean`
Returns:
  JDK information.

#### getOsUser

    public String getOsUser()

Gets OS user.

Specified by:
  `getOsUser` in interface `IgniteMXBean`
Returns:
  OS user name.

#### printLastErrors

    public void printLastErrors()

Prints errors.

Specified by:
  `printLastErrors` in interface `IgniteMXBean`

#### getVmName

    public String getVmName()

Gets VM name.

Specified by:
  `getVmName` in interface `IgniteMXBean`
Returns:
  VM name.

#### getInstanceName

    public String getInstanceName()

Gets optional kernal instance name. It can be `null`.

Specified by:
  `getInstanceName` in interface `IgniteMXBean`
Returns:
  Optional kernal instance name.

#### getExecutorServiceFormatted

    public String getExecutorServiceFormatted()

Gets a formatted instance of fully configured thread pool that is used in grid.

Specified by:
  `getExecutorServiceFormatted` in interface `IgniteMXBean`
Returns:
  Thread pool implementation that is used in grid.

#### getIgniteHome

    public String getIgniteHome()

Gets Ignite installation home folder.

Specified by:
  `getIgniteHome` in interface `IgniteMXBean`
Returns:
  Ignite installation home.

#### getGridLoggerFormatted

    public String getGridLoggerFormatted()

Gets a formatted instance of logger that is in grid.

Specified by:
  `getGridLoggerFormatted` in interface `IgniteMXBean`
Returns:
  Logger that is used in grid.

#### getMBeanServerFormatted

    public String getMBeanServerFormatted()

Gets a formatted instance of MBean server instance.

Specified by:
  `getMBeanServerFormatted` in interface `IgniteMXBean`
Returns:
  MBean server instance.

#### getLocalNodeId

    public UUID getLocalNodeId()

Unique identifier for this node within grid.

Specified by:
  `getLocalNodeId` in interface `IgniteMXBean`
Returns:
  Unique identifier for this node within grid.

#### getUserAttributesFormatted

    public List<String> getUserAttributesFormatted()

Gets a list of formatted user-defined attributes added to this node.

Note that grid will add all System properties and environment properties to grid node attributes also. SPIs may also add node attributes that are used for SPI implementation.

Specified by:
  `getUserAttributesFormatted` in interface `IgniteMXBean`
Returns:
  User defined attributes for this node.

#### isPeerClassLoadingEnabled

    public boolean isPeerClassLoadingEnabled()

Returns `true` if peer class loading is enabled, `false` otherwise. Default value is `true`.

When peer class loading is enabled and task is not deployed on local node, local node will try to load classes from the node that initiated task execution. This way, a task can be physically deployed only on one node and then internally penetrate to all other nodes.

Specified by:
  `isPeerClassLoadingEnabled` in interface `IgniteMXBean`
Returns:
  `true` if peer class loading is enabled, `false` otherwise.

#### getLifecycleBeansFormatted

    public List<String> getLifecycleBeansFormatted()

Gets `toString()` representation of of lifecycle beans configured with Ignite.

Specified by:
  `getLifecycleBeansFormatted` in interface `IgniteMXBean`
Returns:
  `toString()` representation of all lifecycle beans configured with Ignite.

#### start

    public void start(IgniteConfiguration cfg,
             ExecutorService utilityCachePool,
             ExecutorService execSvc,
             ExecutorService svcExecSvc,
             ExecutorService sysExecSvc,
             StripedExecutor stripedExecSvc,
             ExecutorService p2pExecSvc,
             ExecutorService mgmtExecSvc,
             ExecutorService igfsExecSvc,
             ExecutorService dataStreamExecSvc,
             ExecutorService restExecSvc,
             ExecutorService affExecSvc,
             @Nullable
             ExecutorService idxExecSvc,
             IgniteStripedThreadPoolExecutor callbackExecSvc,
             ExecutorService qryExecSvc,
             ExecutorService schemaExecSvc,
             Map<String,? extends ExecutorService> customExecSvcs,
             GridAbsClosure errHnd)
               throws IgniteCheckedException

Parameters:
  `cfg` - Configuration to use.
  `utilityCachePool` - Utility cache pool.
  `execSvc` - Executor service.
  `sysExecSvc` - System executor service.
  `stripedExecSvc` - Striped executor.
  `p2pExecSvc` - P2P executor service.
  `mgmtExecSvc` - Management executor service.
  `igfsExecSvc` - IGFS executor service.
  `dataStreamExecSvc` - data stream executor service.
  `restExecSvc` - Reset executor service.
  `affExecSvc` - Affinity executor service.
  `idxExecSvc` - Indexing executor service.
  `callbackExecSvc` - Callback executor service.
  `qryExecSvc` - Query executor service.
  `schemaExecSvc` - Schema executor service.
  `customExecSvcs` - Custom named executors.
  `errHnd` - Error handler to use for notification about startup problems.
Throws:
  `IgniteCheckedException` - Thrown in case of any errors.

#### stop

    public void stop(boolean cancel)

Stops grid instance.

Parameters:
  `cancel` - Whether or not to cancel running jobs.

#### isStopping

    public boolean isStopping()

Returns:
  `True` if node started shutdown sequence.

#### internalCache

    public <K,V> GridCacheAdapter<K,V> internalCache(String name)

USED ONLY FOR TESTING.

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `name` - Cache name.
Returns:
  Internal cache instance.

#### context

    public GridKernalContext context()

It's intended for use by internal marshalling implementation only.

Specified by:
  `context` in interface `IgniteEx`
Returns:
  Kernal context.

#### isJmxRemoteEnabled

    public boolean isJmxRemoteEnabled()

Whether or not remote JMX management is enabled for this node. Remote JMX management is enabled when the following system property is set:

- `com.sun.management.jmxremote`

Specified by:
  `isJmxRemoteEnabled` in interface `IgniteEx`
Returns:
  `True` if remote JMX management is enabled - `false` otherwise.

#### isRestartEnabled

    public boolean isRestartEnabled()

Whether or not node restart is enabled. Node restart us supported when this node was started with `bin/ignite.{sh|bat}` script using `-r` argument. Node can be programmatically restarted using `Ignition.restart(boolean)`} method.

Specified by:
  `isRestartEnabled` in interface `IgniteEx`
Returns:
  `True` if restart mode is enabled, `false` otherwise.
See Also:
  `Ignition.restart(boolean)`

#### configuration

    public IgniteConfiguration configuration()

Gets the configuration of this Ignite 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.

Specified by:
  `configuration` in interface `Ignite`
Returns:
  Ignite configuration instance.

#### log

    public IgniteLogger log()

Gets grid's logger.

Specified by:
  `log` in interface `Ignite`
Returns:
  Grid's logger.

#### removeCheckpoint

    public boolean removeCheckpoint(String key)

This method allows manually remove the checkpoint with given `key`.

Specified by:
  `removeCheckpoint` in interface `IgniteMXBean`
Parameters:
  `key` - Checkpoint key.
Returns:
  `true` if specified checkpoint was indeed removed, `false` otherwise.

#### pingNode

    public boolean pingNode(String nodeId)

Pings node with given node ID to see whether it is alive.

Specified by:
  `pingNode` in interface `IgniteMXBean`
Parameters:
  `nodeId` - String presentation of node ID. See `UUID.fromString(String)` for details on string formatting.
Returns:
  Whether or not node is alive.

#### undeployTaskFromGrid

    public void undeployTaskFromGrid(String taskName)
                              throws JMException

Makes the best attempt to undeploy a task from the whole grid. Note that this method returns immediately and does not wait until the task will actually be undeployed on every node.

Note that Ignite maintains internal versions for grid tasks in case of redeployment. This method will attempt to undeploy all versions on the grid task with given name.

Specified by:
  `undeployTaskFromGrid` in interface `IgniteMXBean`
Parameters:
  `taskName` - Name of the task to undeploy. If task class has `ComputeTaskName` annotation, then task was deployed under a name specified within annotation. Otherwise, full class name should be used as task's name.
Throws:
  `JMException` - Thrown if undeploy failed.

#### executeTask

    public String executeTask(String taskName,
                     String arg)
                       throws JMException

A shortcut method that executes given task assuming single `java.lang.String` argument and `java.lang.String` return type.

Specified by:
  `executeTask` in interface `IgniteMXBean`
Parameters:
  `taskName` - Name of the task to execute.
  `arg` - Single task execution argument (can be `null`).
Returns:
  Task return value (assumed of `java.lang.String` type).
Throws:
  `JMException` - Thrown in case when execution failed.

#### pingNodeByAddress

    public boolean pingNodeByAddress(String host)

Pings node with given host name to see if it is alive.

Specified by:
  `pingNodeByAddress` in interface `IgniteMXBean`
Parameters:
  `host` - Host name or IP address of the node to ping.
Returns:
  Whether or not node is alive.

#### eventUserRecordable

    public boolean eventUserRecordable(int type)

Checks if the event type is user-recordable.

Specified by:
  `eventUserRecordable` in interface `IgniteEx`
Parameters:
  `type` - Event type to check.
Returns:
  `true` if passed event should be recorded, `false` - otherwise.

#### allEventsUserRecordable

    public boolean allEventsUserRecordable(int[] types)

Checks whether all provided events are user-recordable.

Note that this method supports only predefined Ignite events.

Specified by:
  `allEventsUserRecordable` in interface `IgniteEx`
Parameters:
  `types` - Event types.
Returns:
  Whether all events are recordable.

#### transactions

    public IgniteTransactions transactions()

Gets grid transactions facade.

Specified by:
  `transactions` in interface `Ignite`
Returns:
  Grid transactions facade.

#### getCache

    public <K,V> IgniteInternalCache<K,V> getCache(String name)

Parameters:
  `name` - Cache name.
Returns:
  Cache.

#### cache

    public <K,V> IgniteCache<K,V> cache(String name)

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

Specified by:
  `cache` in interface `Ignite`
Parameters:
  `name` - Cache name.
Returns:
  Instance of the cache for the specified name.

#### createCache

    public <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.

Specified by:
  `createCache` in interface `Ignite`
Parameters:
  `cacheCfg` - Cache configuration to use.
Returns:
  Instance of started cache.

#### createCaches

    public Collection<IgniteCache> createCaches(Collection<CacheConfiguration> cacheCfgs)

Dynamically starts new caches with the given cache configurations.

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

If for one of configurations 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.

Specified by:
  `createCaches` in interface `Ignite`
Parameters:
  `cacheCfgs` - Collection of cache configuration to use.
Returns:
  Collection of instances of started caches.

#### createCache

    public <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.

Specified by:
  `createCache` in interface `Ignite`
Parameters:
  `cacheName` - Cache name.
Returns:
  Instance of started cache.

#### getOrCreateCache

    public <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.

Specified by:
  `getOrCreateCache` in interface `Ignite`
Parameters:
  `cacheCfg` - Cache configuration to use.
Returns:
  Existing or newly created cache.

#### getOrCreateCache0

    public <K,V> IgniteBiTuple<IgniteCache<K,V>,Boolean> getOrCreateCache0(CacheConfiguration<K,V> cacheCfg,
                                                                  boolean sql)

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

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

Specified by:
  `getOrCreateCache0` in interface `IgniteEx`
Parameters:
  `cacheCfg` - Cache configuration to use.
  `sql` - `true` if this call is triggered by SQL command `CREATE TABLE`, `false` otherwise.
Returns:
  Tuple [Existing or newly created cache; `true` if cache was newly crated, `false` otherwise]

#### getOrCreateCaches

    public Collection<IgniteCache> getOrCreateCaches(Collection<CacheConfiguration> cacheCfgs)

Gets existing caches with the given name or created 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.

Specified by:
  `getOrCreateCaches` in interface `Ignite`
Parameters:
  `cacheCfgs` - Collection of cache configuration to use.
Returns:
  Collection of existing or newly created caches.

#### createCache

    public <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.

Specified by:
  `createCache` in interface `Ignite`
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

    public <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.

Specified by:
  `getOrCreateCache` in interface `Ignite`
Parameters:
  `cacheCfg` - Cache configuration.
  `nearCfg` - Near cache configuration for client.
Returns:
  `IgniteCache` instance.

#### createNearCache

    public <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 `Ignite.createCache(CacheConfiguration)` or `Ignite.createCache(CacheConfiguration, NearCacheConfiguration)` methods.

Specified by:
  `createNearCache` in interface `Ignite`
Parameters:
  `cacheName` - Cache name.
  `nearCfg` - Near cache configuration.
Returns:
  Cache instance.

#### getOrCreateNearCache

    public <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.

Specified by:
  `getOrCreateNearCache` in interface `Ignite`
Parameters:
  `cacheName` - Cache name.
  `nearCfg` - Near configuration.
Returns:
  `IgniteCache` instance.

#### destroyCache

    public void destroyCache(String cacheName)

Stops dynamically started cache.

Specified by:
  `destroyCache` in interface `Ignite`
Parameters:
  `cacheName` - Cache name to stop.

#### destroyCache0

    public boolean destroyCache0(String cacheName,
                        boolean sql)
                          throws javax.cache.CacheException

Stops dynamically started cache.

Specified by:
  `destroyCache0` in interface `IgniteEx`
Parameters:
  `cacheName` - Cache name to stop.
  `sql` - `true` if only cache created with SQL command `CREATE TABLE` should be affected, `false` otherwise.
Returns:
  `true` if cache has been stopped as the result of this call, `false` otherwise.
Throws:
  `javax.cache.CacheException` - If error occurs.

#### destroyCaches

    public void destroyCaches(Collection<String> cacheNames)

Stops dynamically started caches.

Specified by:
  `destroyCaches` in interface `Ignite`
Parameters:
  `cacheNames` - Collection of cache names to stop.

#### destroyCacheAsync

    public IgniteInternalFuture<Boolean> destroyCacheAsync(String cacheName,
                                                  boolean sql,
                                                  boolean checkThreadTx)

Parameters:
  `cacheName` - Cache name.
  `sql` - If the cache needs to be destroyed only if it was created by SQL `CREATE TABLE` command.
  `checkThreadTx` - If `true` checks that current thread does not have active transactions.
Returns:
  Ignite future.

#### destroyCachesAsync

    public IgniteInternalFuture<?> destroyCachesAsync(Collection<String> cacheNames,
                                             boolean checkThreadTx)

Parameters:
  `cacheNames` - Collection of cache names.
  `checkThreadTx` - If `true` checks that current thread does not have active transactions.
Returns:
  Ignite future.

#### getOrCreateCache

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

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

Specified by:
  `getOrCreateCache` in interface `Ignite`
Parameters:
  `cacheName` - Cache name.
Returns:
  Existing or newly created cache.

#### getOrCreateCacheAsync

    public IgniteInternalFuture<?> getOrCreateCacheAsync(String cacheName,
                                                boolean checkThreadTx)

Parameters:
  `cacheName` - Cache name.
  `checkThreadTx` - If `true` checks that current thread does not have active transactions.
Returns:
  Future that will be completed when cache is deployed.

#### addCacheConfiguration

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

Adds cache configuration template.

Specified by:
  `addCacheConfiguration` in interface `Ignite`
Parameters:
  `cacheCfg` - Cache configuration template.

#### caches

    public Collection<IgniteCacheProxy<?,?>> caches()

Returns:
  Public caches.

#### cacheNames

    public 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.

Specified by:
  `cacheNames` in interface `Ignite`
Returns:
  Collection of names of currently available caches or an empty collection if no caches are available.

#### utilityCache

    public <K extends GridCacheUtilityKey,V> IgniteInternalCache<K,V> utilityCache()

Gets utility cache.

Specified by:
  `utilityCache` in interface `IgniteEx`
Returns:
  Utility cache.

#### cachex

    public <K,V> IgniteInternalCache<K,V> cachex(String name)

Gets the cache instance for the given name if one is configured or `null` otherwise returning even non-public caches.

Specified by:
  `cachex` in interface `IgniteEx`
Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `name` - Cache name.
Returns:
  Cache instance for given name or `null` if one does not exist.

#### cachesx

    public Collection<IgniteInternalCache<?,?>> cachesx(IgnitePredicate<? super IgniteInternalCache<?,?>>[] p)

Gets configured cache instance that satisfy all provided predicates including non-public caches. If no predicates provided - all configured caches will be returned.

Specified by:
  `cachesx` in interface `IgniteEx`
Parameters:
  `p` - Predicates. If none provided - all configured caches will be returned.
Returns:
  Configured cache instances that satisfy all provided predicates.

#### dataStreamer

    public <K,V> IgniteDataStreamer<K,V> dataStreamer(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.

Specified by:
  `dataStreamer` in interface `Ignite`
Parameters:
  `cacheName` - Cache name.
Returns:
  Data streamer.

#### fileSystem

    public 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.

Specified by:
  `fileSystem` in interface `Ignite`
Parameters:
  `name` - IGFS name.
Returns:
  IGFS instance.

#### igfsx

    @Nullable
    public IgniteFileSystem igfsx(String name)

Get IGFS instance returning null if it doesn't exist.

Specified by:
  `igfsx` in interface `IgniteEx`
Parameters:
  `name` - IGFS name.
Returns:
  IGFS.

#### fileSystems

    public Collection<IgniteFileSystem> fileSystems()

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

Specified by:
  `fileSystems` in interface `Ignite`
Returns:
  Collection of IGFS instances.

#### hadoop

    public Hadoop hadoop()

Get Hadoop facade.

Specified by:
  `hadoop` in interface `IgniteEx`
Returns:
  Hadoop.

#### plugin

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

Gets an instance of deployed Ignite plugin.

Specified by:
  `plugin` in interface `Ignite`
Type Parameters:
  `T` - Plugin type.
Parameters:
  `name` - Plugin name.
Returns:
  Plugin instance.
Throws:
  `PluginNotFoundException` - If plugin for the given name was not found.

#### binary

    public IgniteBinary binary()

Gets an instance of `IgniteBinary` interface.

Specified by:
  `binary` in interface `Ignite`
Returns:
  Instance of `IgniteBinary` interface.

#### version

    public IgniteProductVersion version()

Gets Ignite version.

Specified by:
  `version` in interface `Ignite`
Returns:
  Ignite version.

#### latestVersion

    public String latestVersion()

Get latest version in string form.

Specified by:
  `latestVersion` in interface `IgniteEx`
Returns:
  Latest version.

#### scheduler

    public IgniteScheduler scheduler()

Gets an instance of cron-based scheduler.

Specified by:
  `scheduler` in interface `Ignite`
Returns:
  Instance of scheduler.

#### close

    public void close()
               throws IgniteException

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

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

Specified by:
  `close` in interface `AutoCloseable`
Specified by:
  `close` in interface `Ignite`
Throws:
  `IgniteException` - If failed to stop grid.

#### affinity

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

Description copied from interface: `Ignite`
Gets affinity service to provide information about data partitioning and distribution.

Specified by:
  `affinity` in interface `Ignite`
Type Parameters:
  `K` - Cache key type.
Parameters:
  `cacheName` - Cache name.
Returns:
  Affinity.

#### active

    public boolean active()

Checks Ignite grid is active or not active.

Specified by:
  `active` in interface `Ignite`
Specified by:
  `active` in interface `IgniteMXBean`
Returns:
  `True` if grid is active. `False` If grid is not active.

#### active

    public void active(boolean active)

Changes Ignite grid state to active or inactive.

Specified by:
  `active` in interface `Ignite`
Specified by:
  `active` in interface `IgniteMXBean`
Parameters:
  `active` - If `True` start activation process. If `False` start deactivation process.

#### resetLostPartitions

    public void resetLostPartitions(Collection<String> cacheNames)

Clears partition's lost state and moves caches to a normal mode.

Specified by:
  `resetLostPartitions` in interface `Ignite`

#### memoryMetrics

    public Collection<MemoryMetrics> memoryMetrics()

Returns a collection of `MemoryMetrics` that reflects page memory usage on this Apache Ignite node instance. Returns the collection that contains the latest snapshots for each memory region configured with `configuration` on this Ignite node instance.

Specified by:
  `memoryMetrics` in interface `Ignite`
Returns:
  Collection of `MemoryMetrics` snapshots.

#### memoryMetrics

    @Nullable
    public MemoryMetrics memoryMetrics(String memPlcName)

Returns the latest `MemoryMetrics` snapshot for the memory region of the given name. To get the metrics for the default memory region use `MemoryConfiguration.DFLT_MEM_PLC_DEFAULT_NAME` as the name or a custom name if the default memory region has been renamed.

Specified by:
  `memoryMetrics` in interface `Ignite`
Parameters:
  `memPlcName` - Name of memory region configured with `config`.
Returns:
  `MemoryMetrics` snapshot or `null` if no memory region is configured under specified name.

#### persistentStoreMetrics

    public PersistenceMetrics persistentStoreMetrics()

Specified by:
  `persistentStoreMetrics` in interface `Ignite`
Returns:
  `PersistenceMetrics` snapshot.

#### atomicSequence

    @Nullable
    public 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`. It will use configuration from `IgniteConfiguration.getAtomicConfiguration()`.

Specified by:
  `atomicSequence` in interface `Ignite`
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.

#### atomicSequence

    @Nullable
    public IgniteAtomicSequence atomicSequence(String name,
                                               AtomicConfiguration cfg,
                                               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`.

Specified by:
  `atomicSequence` in interface `Ignite`
Parameters:
  `name` - Sequence name.
  `cfg` - Configuration.
  `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

    @Nullable
    public 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`.

Specified by:
  `atomicLong` in interface `Ignite`
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.

#### atomicLong

    @Nullable
    public IgniteAtomicLong atomicLong(String name,
                                       AtomicConfiguration cfg,
                                       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`.

Specified by:
  `atomicLong` in interface `Ignite`
Parameters:
  `name` - Name of atomic long.
  `cfg` - Configuration.
  `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

    @Nullable
    public <T> IgniteAtomicReference<T> atomicReference(String name,
                                                        @Nullable
                                                        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`. It will use configuration from `IgniteConfiguration.getAtomicConfiguration()`.

Specified by:
  `atomicReference` in interface `Ignite`
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.

#### atomicReference

    public <T> IgniteAtomicReference<T> atomicReference(String name,
                                               AtomicConfiguration cfg,
                                               @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`.

Specified by:
  `atomicReference` in interface `Ignite`
Parameters:
  `name` - Atomic reference name.
  `cfg` - Configuration.
  `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

    @Nullable
    public <T,S> IgniteAtomicStamped<T,S> atomicStamped(String name,
                                                        @Nullable
                                                        T initVal,
                                                        @Nullable
                                                        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`.

Specified by:
  `atomicStamped` in interface `Ignite`
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.

#### atomicStamped

    public <T,S> IgniteAtomicStamped<T,S> atomicStamped(String name,
                                               AtomicConfiguration cfg,
                                               @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`.

Specified by:
  `atomicStamped` in interface `Ignite`
Parameters:
  `name` - Atomic stamped name.
  `cfg` - Configuration.
  `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

    @Nullable
    public IgniteCountDownLatch countDownLatch(String name,
                                               int cnt,
                                               boolean autoDel,
                                               boolean create)

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.

Specified by:
  `countDownLatch` in interface `Ignite`
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.

#### semaphore

    @Nullable
    public IgniteSemaphore semaphore(String name,
                                     int cnt,
                                     boolean failoverSafe,
                                     boolean create)

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.

Specified by:
  `semaphore` in interface `Ignite`
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.

#### reentrantLock

    @Nullable
    public IgniteLock reentrantLock(String name,
                                    boolean failoverSafe,
                                    boolean fair,
                                    boolean create)

Gets or creates reentrant lock. If reentrant lock is not found in cache and `create` flag is `true`, it is created using provided name.

Specified by:
  `reentrantLock` in interface `Ignite`
Parameters:
  `name` - Name of the lock.
  `failoverSafe` - `True` to create failover safe lock which means that if any node leaves topology, all locks already acquired by that node are silently released and become available for other nodes to acquire. If flag is `false` then all threads on other nodes waiting to acquire lock are interrupted.
  `fair` - If `True`, fair lock will be created.
  `create` - Boolean flag indicating whether data structure should be created if does not exist.
Returns:
  ReentrantLock for the given name.

#### queue

    @Nullable
    public <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`. 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.

Specified by:
  `queue` in interface `Ignite`
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.

#### set

    @Nullable
    public <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`.

Specified by:
  `set` in interface `Ignite`
Parameters:
  `name` - Set name.
  `cfg` - Set configuration if new set should be created.
Returns:
  Set with given properties.

#### onDisconnected

    public void onDisconnected()

#### onReconnected

    public void onReconnected(boolean clusterRestarted)

Parameters:
  `clusterRestarted` - `True` if all cluster nodes restarted while client was disconnected.

#### readExternal

    public void readExternal(ObjectInput in)
                      throws IOException,
                             ClassNotFoundException

Specified by:
  `readExternal` in interface `Externalizable`
Throws:
  `IOException`
  `ClassNotFoundException`

#### writeExternal

    public void writeExternal(ObjectOutput out)
                       throws IOException

Specified by:
  `writeExternal` in interface `Externalizable`
Throws:
  `IOException`

#### readResolve

    protected Object readResolve()
                          throws ObjectStreamException

Returns:
  IgniteKernal instance.
Throws:
  `ObjectStreamException` - If failed.

#### dumpDebugInfo

    public void dumpDebugInfo()

Dumps debug information for the current node.

Specified by:
  `dumpDebugInfo` in interface `IgniteMXBean`

#### sendIoTest

    public IgniteInternalFuture sendIoTest(ClusterNode node,
                                  byte[] payload,
                                  boolean procFromNioThread)

Parameters:
  `node` - Node.
  `payload` - Message payload.
  `procFromNioThread` - If `true` message is processed from NIO thread.
Returns:
  Response future.

#### sendIoTest

    public IgniteInternalFuture sendIoTest(List<ClusterNode> nodes,
                                  byte[] payload,
                                  boolean procFromNioThread)

Parameters:
  `nodes` - Nodes.
  `payload` - Message payload.
  `procFromNioThread` - If `true` message is processed from NIO thread.
Returns:
  Response future.

#### runIoTest

    public void runIoTest(long warmup,
                 long duration,
                 int threads,
                 long maxLatency,
                 int rangesCnt,
                 int payLoadSize,
                 boolean procFromNioThread)

Runs IO latency test against all remote server nodes in cluster.

Specified by:
  `runIoTest` in interface `IgniteMXBean`
Parameters:
  `warmup` - Warmup duration in milliseconds.
  `duration` - Test duration in milliseconds.
  `threads` - Thread count.
  `maxLatency` - Max latency in nanoseconds.
  `rangesCnt` - Ranges count in resulting histogram.
  `payLoadSize` - Payload size in bytes.
  `procFromNioThread` - `True` to process requests in NIO threads.

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`

2017 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 2.1.0
Release Date | : July 20 2017