Package org.apache.ignite.internal

Class IgniteKernal

    • Constructor Detail

      • IgniteKernal

        public IgniteKernal()
        No-arg constructor is required by externalization.

      • IgniteKernal

        public IgniteKernal​(@Nullable
                    @Nullable GridSpringResourceContext rsrcCtx)
        Parameters:
        rsrcCtx - Optional Spring application context.

    • Method Detail

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

      • isRebalanceEnabled

        public boolean isRebalanceEnabled()
        Get rebalance enabled flag.
        Specified by:
        isRebalanceEnabled in interface IgniteEx
        Returns:
        True if rebalance enabled on node, False otherwise.

      • rebalanceEnabled

        public void rebalanceEnabled​(boolean rebalanceEnabled)
        Set rebalance enable flag on node.
        Specified by:
        rebalanceEnabled in interface IgniteEx
        Parameters:
        rebalanceEnabled - rebalance enabled flag.

      • upTimeFormatted

        public String upTimeFormatted()
        Returns:
        String representation of the uptime.

      • vmName

        public String vmName()
        Returns:
        Name of the VM.

      • localNodeId

        public UUID localNodeId()
        Returns:
        Id of the local node.

      • dataStorageReport

        public void dataStorageReport()

      • stop

        public void stop​(boolean cancel)
        Stops Ignite 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.

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

      • getCache

        public <K,​V> IgniteInternalCache<K,​V> getCache​(String name)
        Parameters:
        name - Cache name.
        Returns:
        Ignite internal cache instance related to the given name.

      • cache

        public <K,​V> IgniteCache<K,​V> cache​(String name)
        Gets an instance of IgniteCache API for the given name if one is configured or null otherwise. IgniteCache is a fully-compatible implementation of JCache (JSR 107) specification.
        Specified by:
        cache in interface Ignite
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        Parameters:
        name - Cache name.
        Returns:
        Instance of the cache for the specified name or null if one does not exist.

      • 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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        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
        Type Parameters:
        K - type.
        V - type.
        Parameters:
        cacheCfg - Cache configuration.
        nearCfg - Near cache configuration for client.
        Returns:
        IgniteCache 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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        Parameters:
        cacheName - Cache name.
        nearCfg - Near configuration.
        Returns:
        IgniteCache instance.

      • destroyCache

        public void destroyCache​(String cacheName)
        Destroys a cache with the given name and cleans data that was written to the cache. The call will deallocate all resources associated with the given cache on all nodes in the cluster. There is no way to undo the action and recover destroyed data.

        All existing instances of IgniteCache will be invalidated, subsequent calls to the API will throw exceptions.

        If a cache with the specified name does not exist in the grid, the operation has no effect.

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

      • 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)
        Destroys caches with the given names and cleans data that was written to the caches. The call will deallocate all resources associated with the given caches on all nodes in the cluster. There is no way to undo the action and recover destroyed data.

        All existing instances of IgniteCache will be invalidated, subsequent calls to the API will throw exceptions.

        If the specified collection contains null or an empty value, this method will throw IllegalArgumentException and the caches will not be destroyed.

        If a cache with the specified name does not exist in the grid, the specified value will be skipped.

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

      • 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 which will be completed when cache is destored.

      • 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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        Parameters:
        cacheName - Cache name.
        Returns:
        Existing or newly created cache.

      • getOrCreateCacheAsync

        public IgniteInternalFuture<?> getOrCreateCacheAsync​(String cacheName,
                                                     String templateName,
                                                     CacheConfigurationOverride cfgOverride,
                                                     boolean checkThreadTx)
        Parameters:
        cacheName - Cache name.
        templateName - Template name.
        cfgOverride - Cache config properties to override.
        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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        Parameters:
        cacheCfg - Cache configuration template.

      • cacheNames

        public Collection<String> cacheNames()
        Gets the collection of names of currently available caches.
        Specified by:
        cacheNames in interface Ignite
        Returns:
        Collection of names of currently available caches or an empty collection if no caches are available.

      • 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
        Type Parameters:
        K - Type of the cache key.
        V - Type of the cache value.
        Parameters:
        cacheName - Cache name.
        Returns:
        Data streamer.

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

      • affinity

        public <K> Affinity<K> affinity​(String cacheName)
        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
        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.

        NOTE: Deactivation clears in-memory caches (without persistence) including the system caches.

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

        To avoid permanent data loss for persistent caches it's recommended to return all previously failed baseline nodes to the topology before calling this method.

        Specified by:
        resetLostPartitions in interface Ignite
        Parameters:
        cacheNames - Name of the caches for which lost partitions is reset.

      • tracingConfiguration

        @NotNull
public @NotNull TracingConfigurationManager tracingConfiguration()
        Returns the TracingConfigurationManager instance that allows to
        • Configure tracing parameters such as sampling rate for the specific tracing coordinates such as scope and label.
        • Retrieve the most specific tracing parameters for the specified tracing coordinates (scope and label)
        • Restore the tracing parameters for the specified tracing coordinates to the default.
        • List all pairs of tracing configuration coordinates and tracing configuration parameters.
        Specified by:
        tracingConfiguration in interface Ignite
        Returns:
        TracingConfigurationManager instance.

      • memoryMetrics

        @Nullable
public @Nullable MemoryMetrics memoryMetrics​(String memPlcName)
        Specified by:
        memoryMetrics in interface Ignite
        Parameters:
        memPlcName - Name of the data region.
        Returns:
        MemoryMetrics snapshot or null if no memory region is configured under specified name.

      • atomicSequence

        @Nullable
public @Nullable 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 @Nullable 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 @Nullable 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 @Nullable 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> @Nullable 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
        Type Parameters:
        T - Type of object referred to by this reference.
        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
        Type Parameters:
        T - Type of object referred to by this reference.
        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> @Nullable 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
        Type Parameters:
        T - Type of object referred to by this atomic.
        S - Type of stamp object.
        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
        Type Parameters:
        T - Type of object referred to by this atomic.
        S - Type of stamp object.
        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 @Nullable 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 @Nullable 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 @Nullable 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> @Nullable 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
        Type Parameters:
        T - Type of the elements in queue.
        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> @Nullable 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
        Type Parameters:
        T - Type of the elements in set.
        Parameters:
        name - Set name.
        cfg - Set configuration if new set should be created.
        Returns:
        Set with given properties.

      • set

        public <T> IgniteSet<T> set​(String name,
                            int cacheId,
                            boolean collocated,
                            boolean separated)
                     throws IgniteException
        Gets a set from cache by known cache id. Does not create new sets.
        Specified by:
        set in interface IgniteEx
        Type Parameters:
        T - Type of the elements in set.
        Parameters:
        name - Set name.
        cacheId - Cache id.
        collocated - Colocated mode flag.
        separated - Separated cache flag.
        Returns:
        Set with given properties.
        Throws:
        IgniteException - If set could not be fetched or created.

      • onDisconnected

        public void onDisconnected()
        Method is responsible for handling the EventType.EVT_CLIENT_NODE_DISCONNECTED event. Notify all the GridComponents that the such even has been occurred (e.g. if the local client node disconnected from the cluster components will be notified with a future which will be completed when the client is reconnected).

      • onReconnected

        public void onReconnected​(boolean clusterRestarted)
        Parameters:
        clusterRestarted - True if all cluster nodes restarted while client was disconnected.

      • dumpDebugInfo

        public void dumpDebugInfo()
        Dumps debug information for the current node.

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