ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [04/48] incubator-ignite git commit: IGNITE-383 Rename preload to rebalance.
Date Thu, 12 Mar 2015 10:15:50 GMT
IGNITE-383 Rename preload to rebalance.


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/dc04e98c
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/dc04e98c
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/dc04e98c

Branch: refs/heads/ignite-394
Commit: dc04e98c616ec68f13d591c1536fb2b275f20744
Parents: 11efb91
Author: nikolay_tikhonov <ntikhonov@gridgain.com>
Authored: Mon Mar 2 16:53:06 2015 +0300
Committer: nikolay_tikhonov <ntikhonov@gridgain.com>
Committed: Mon Mar 2 16:56:02 2015 +0300

----------------------------------------------------------------------
 examples/config/example-cache.xml               |   4 +-
 .../MemcacheRestExampleNodeStartup.java         |   5 +-
 .../clients/src/test/resources/spring-cache.xml |   8 +-
 .../apache/ignite/cache/CachePreloadMode.java   |  67 ------
 .../apache/ignite/cache/CacheRebalanceMode.java |  67 ++++++
 .../java/org/apache/ignite/cache/GridCache.java |  14 +-
 .../configuration/CacheConfiguration.java       | 232 +++++++++----------
 .../ignite/events/CachePreloadingEvent.java     | 172 --------------
 .../ignite/events/CacheRebalancingEvent.java    | 172 ++++++++++++++
 .../java/org/apache/ignite/events/Event.java    |   2 +-
 .../org/apache/ignite/events/EventType.java     |  46 ++--
 .../org/apache/ignite/internal/IgnitionEx.java  |   6 +-
 .../processors/cache/GridCacheAttributes.java   |  32 +--
 .../processors/cache/GridCacheContext.java      |   8 +-
 .../processors/cache/GridCacheEventManager.java |  12 +-
 .../cache/GridCacheEvictionManager.java         |   6 +-
 .../GridCachePartitionExchangeManager.java      |   6 +-
 .../processors/cache/GridCacheProcessor.java    |  74 +++---
 .../processors/cache/GridCacheUtils.java        |   4 +-
 .../distributed/dht/GridDhtLocalPartition.java  |   4 +-
 .../distributed/dht/GridDhtLockFuture.java      |   4 +-
 .../dht/GridDhtPartitionTopologyImpl.java       |  14 +-
 .../distributed/dht/GridDhtTxPrepareFuture.java |   4 +-
 .../dht/preloader/GridDhtForceKeysFuture.java   |  30 +--
 .../preloader/GridDhtPartitionDemandPool.java   |  76 +++---
 .../preloader/GridDhtPartitionSupplyPool.java   |  22 +-
 .../dht/preloader/GridDhtPreloader.java         |  14 +-
 .../cache/VisorCachePreloadConfiguration.java   |  16 +-
 .../core/src/test/config/discovery-stress.xml   |   2 +-
 modules/core/src/test/config/example-cache.xml  |   4 +-
 .../config/load/dsi-49-server-production.xml    |   4 +-
 .../src/test/config/load/dsi-load-client.xml    |   4 +-
 .../src/test/config/load/dsi-load-server.xml    |   4 +-
 .../core/src/test/config/spring-cache-load.xml  |   2 +-
 .../core/src/test/config/spring-multicache.xml  |  16 +-
 .../test/config/websession/spring-cache-1.xml   |   6 +-
 .../test/config/websession/spring-cache-2.xml   |   6 +-
 .../test/config/websession/spring-cache-3.xml   |   6 +-
 .../GridDiscoveryManagerAliveCacheSelfTest.java |   4 +-
 .../GridCacheAbstractFailoverSelfTest.java      |   4 +-
 .../cache/GridCacheBasicStoreAbstractTest.java  |   4 +-
 .../GridCacheConcurrentTxMultiNodeTest.java     |   4 +-
 ...idCacheConfigurationConsistencySelfTest.java |   6 +-
 ...ridCacheConfigurationValidationSelfTest.java |   8 +-
 .../cache/GridCacheDeploymentSelfTest.java      |   4 +-
 ...idCacheGetAndTransformStoreAbstractTest.java |   4 +-
 .../cache/GridCacheIncrementTransformTest.java  |   4 +-
 .../cache/GridCacheMultiUpdateLockSelfTest.java |   4 +-
 .../GridCacheOrderedPreloadingSelfTest.java     |   6 +-
 .../cache/GridCacheP2PUndeploySelfTest.java     |   8 +-
 .../cache/GridCachePartitionedGetSelfTest.java  |   4 +-
 ...hePartitionedProjectionAffinitySelfTest.java |   4 +-
 .../GridCachePreloadingEvictionsSelfTest.java   |   6 +-
 .../GridCacheQueryInternalKeysSelfTest.java     |   4 +-
 .../cache/GridCacheSwapPreloadSelfTest.java     |   4 +-
 .../GridCacheValueBytesPreloadingSelfTest.java  |   2 +-
 ...idCacheValueConsistencyAbstractSelfTest.java |   4 +-
 .../IgniteCacheAbstractStopBusySelfTest.java    |   2 +-
 ...tAllUpdateNonPreloadedPartitionSelfTest.java |   2 +-
 .../IgniteCollectionAbstractTest.java           |   4 +-
 ...GridCachePartitionedNodeRestartSelfTest.java |   4 +-
 ...idCachePartitionedNodeRestartTxSelfTest.java |   4 +-
 ...PartitionedQueueCreateMultiNodeSelfTest.java |   4 +-
 .../GridCacheAbstractNodeRestartSelfTest.java   |   6 +-
 .../GridCacheAbstractPrimarySyncSelfTest.java   |   4 +-
 ...acheEntrySetIterationPreloadingSelfTest.java |   2 +-
 ...heExpiredEntriesPreloadAbstractSelfTest.java |   6 +-
 .../distributed/GridCacheLockAbstractTest.java  |   4 +-
 ...dCacheMultithreadedFailoverAbstractTest.java |   4 +-
 ...dCachePartitionedAffinityFilterSelfTest.java |   4 +-
 .../GridCachePreloadEventsAbstractSelfTest.java |   8 +-
 .../GridCachePreloadLifecycleAbstractTest.java  |   6 +-
 ...GridCachePreloadRestartAbstractSelfTest.java |  10 +-
 ...iteTxConsistencyRestartAbstractSelfTest.java |   4 +-
 .../IgniteTxPreloadAbstractTest.java            |   4 +-
 .../dht/GridCacheAtomicNearCacheSelfTest.java   |   4 +-
 ...dCacheColocatedTxSingleThreadedSelfTest.java |   4 +-
 ...GridCacheDhtEvictionNearReadersSelfTest.java |   4 +-
 .../dht/GridCacheDhtEvictionSelfTest.java       |   4 +-
 .../dht/GridCacheDhtInternalEntrySelfTest.java  |   4 +-
 .../dht/GridCacheDhtMappingSelfTest.java        |   4 +-
 .../dht/GridCacheDhtPreloadBigDataSelfTest.java |  10 +-
 .../dht/GridCacheDhtPreloadDelayedSelfTest.java |  20 +-
 .../GridCacheDhtPreloadDisabledSelfTest.java    |   8 +-
 .../GridCacheDhtPreloadMessageCountTest.java    |   4 +-
 .../dht/GridCacheDhtPreloadPutGetSelfTest.java  |   6 +-
 .../dht/GridCacheDhtPreloadSelfTest.java        |  28 +--
 .../GridCacheDhtPreloadStartStopSelfTest.java   |  12 +-
 .../dht/GridCacheDhtPreloadUnloadSelfTest.java  |  10 +-
 ...ePartitionedNearDisabledMetricsSelfTest.java |   4 +-
 ...idCachePartitionedPreloadEventsSelfTest.java |   8 +-
 ...dCachePartitionedTopologyChangeSelfTest.java |   4 +-
 ...ridCachePartitionedUnloadEventsSelfTest.java |  13 +-
 ...eAtomicInvalidPartitionHandlingSelfTest.java |   4 +-
 ...unctionExcludeNeighborsAbstractSelfTest.java |   4 +-
 ...GridCacheAtomicMultiNodeFullApiSelfTest.java |   4 +-
 ...idCacheAtomicPartitionedMetricsSelfTest.java |   4 +-
 .../near/GridCacheNearEvictionSelfTest.java     |   7 +-
 .../near/GridCacheNearMultiGetSelfTest.java     |   4 +-
 .../near/GridCacheNearOnlyTopologySelfTest.java |   4 +-
 .../GridCacheNearPartitionedClearSelfTest.java  |   4 +-
 .../near/GridCacheNearReadersSelfTest.java      |   4 +-
 .../near/GridCacheNearTxMultiNodeSelfTest.java  |   4 +-
 ...AffinityExcludeNeighborsPerformanceTest.java |   4 +-
 .../GridCachePartitionedAffinitySelfTest.java   |   4 +-
 .../GridCachePartitionedBasicOpSelfTest.java    |   2 +-
 .../near/GridCachePartitionedEventSelfTest.java |   4 +-
 ...idCachePartitionedHitsAndMissesSelfTest.java |   2 +-
 .../GridCachePartitionedMetricsSelfTest.java    |   4 +-
 ...achePartitionedMultiNodeCounterSelfTest.java |   4 +-
 ...achePartitionedMultiNodeFullApiSelfTest.java |   4 +-
 .../GridCachePartitionedNodeRestartTest.java    |   4 +-
 ...ePartitionedOptimisticTxNodeRestartTest.java |   4 +-
 ...achePartitionedPreloadLifecycleSelfTest.java |   4 +-
 ...hePartitionedQueryMultiThreadedSelfTest.java |   2 +-
 .../GridCachePartitionedTxSalvageSelfTest.java  |   2 +-
 ...achePartitionedTxSingleThreadedSelfTest.java |   4 +-
 .../GridCacheReplicatedInvalidateSelfTest.java  |   4 +-
 .../GridCacheReplicatedNodeRestartSelfTest.java |   6 +-
 .../GridCacheSyncReplicatedPreloadSelfTest.java |   6 +-
 ...CacheReplicatedPreloadLifecycleSelfTest.java |   4 +-
 .../GridCacheReplicatedPreloadSelfTest.java     |  16 +-
 ...eplicatedPreloadStartStopEventsSelfTest.java |   6 +-
 .../GridCacheEvictionFilterSelfTest.java        |   4 +-
 .../GridCacheLruNearEvictionPolicySelfTest.java |   4 +-
 ...heNearOnlyLruNearEvictionPolicySelfTest.java |   4 +-
 ...ridCacheContinuousQueryAbstractSelfTest.java |   4 +-
 ...dCacheAbstractReduceFieldsQuerySelfTest.java |   4 +-
 .../processors/igfs/IgfsSizeSelfTest.java       |   8 +-
 .../loadtests/GridCacheMultiNodeLoadTest.java   |   4 +-
 .../capacity/spring-capacity-cache.xml          |   4 +-
 .../loadtests/colocation/spring-colocation.xml  |   4 +-
 .../GridCachePartitionedAtomicLongLoadTest.java |   2 +-
 .../GridP2PContinuousDeploymentSelfTest.java    |   4 +-
 .../tcp/GridCacheDhtLockBackupSelfTest.java     |   4 +-
 .../junits/common/GridCommonAbstractTest.java   |   4 +-
 .../webapp/META-INF/ignite-webapp-config.xml    |  12 +-
 .../GridCacheAbstractFieldsQuerySelfTest.java   |   4 +-
 .../cache/GridCacheAbstractQuerySelfTest.java   |   4 +-
 .../cache/GridCacheCrossCacheQuerySelfTest.java |   4 +-
 .../GridCacheCrossCacheQuerySelfTestNewApi.java |   4 +-
 .../cache/GridIndexingWithNoopSwapSelfTest.java |   4 +-
 .../near/GridCacheQueryNodeRestartSelfTest.java |   6 +-
 .../query/h2/sql/GridQueryParsingTest.java      |   5 +-
 .../tcp/GridOrderedMessageCancelSelfTest.java   |   4 +-
 .../commands/events/VisorEventsCommand.scala    |   4 +-
 .../scala/org/apache/ignite/visor/visor.scala   |   4 +-
 147 files changed, 864 insertions(+), 874 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/examples/config/example-cache.xml
----------------------------------------------------------------------
diff --git a/examples/config/example-cache.xml b/examples/config/example-cache.xml
index 2ccecf9..8c7fee5 100644
--- a/examples/config/example-cache.xml
+++ b/examples/config/example-cache.xml
@@ -140,8 +140,8 @@
         <!-- Initial cache size. -->
         <property name="startSize" value="3000000"/>
 
-        <!-- Set synchronous preloading (default is asynchronous). -->
-        <property name="preloadMode" value="SYNC"/>
+        <!-- Set synchronous rebalancing (default is asynchronous). -->
+        <property name="rebalanceMode" value="SYNC"/>
 
         <!-- Set to FULL_SYNC for examples, default is PRIMARY_SYNC. -->
         <property name="writeSynchronizationMode" value="FULL_SYNC"/>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/examples/src/main/java/org/apache/ignite/examples/misc/client/memcache/MemcacheRestExampleNodeStartup.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java/org/apache/ignite/examples/misc/client/memcache/MemcacheRestExampleNodeStartup.java b/examples/src/main/java/org/apache/ignite/examples/misc/client/memcache/MemcacheRestExampleNodeStartup.java
index 1b2b41e..b856fc4 100644
--- a/examples/src/main/java/org/apache/ignite/examples/misc/client/memcache/MemcacheRestExampleNodeStartup.java
+++ b/examples/src/main/java/org/apache/ignite/examples/misc/client/memcache/MemcacheRestExampleNodeStartup.java
@@ -18,7 +18,6 @@
 package org.apache.ignite.examples.misc.client.memcache;
 
 import org.apache.ignite.*;
-import org.apache.ignite.cache.query.*;
 import org.apache.ignite.configuration.*;
 import org.apache.ignite.marshaller.optimized.*;
 import org.apache.ignite.spi.discovery.tcp.*;
@@ -27,7 +26,7 @@ import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.*;
 import java.util.*;
 
 import static org.apache.ignite.cache.CacheAtomicityMode.*;
-import static org.apache.ignite.cache.CachePreloadMode.*;
+import static org.apache.ignite.cache.CacheRebalanceMode.*;
 import static org.apache.ignite.cache.CacheWriteSynchronizationMode.*;
 import static org.apache.ignite.configuration.DeploymentMode.*;
 
@@ -73,7 +72,7 @@ public class MemcacheRestExampleNodeStartup {
 
         cacheCfg.setAtomicityMode(TRANSACTIONAL);
         cacheCfg.setWriteSynchronizationMode(FULL_SYNC);
-        cacheCfg.setPreloadMode(SYNC);
+        cacheCfg.setRebalanceMode(SYNC);
         cacheCfg.setAtomicityMode(TRANSACTIONAL);
 
         CacheQueryConfiguration qryCfg = new CacheQueryConfiguration();

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/clients/src/test/resources/spring-cache.xml
----------------------------------------------------------------------
diff --git a/modules/clients/src/test/resources/spring-cache.xml b/modules/clients/src/test/resources/spring-cache.xml
index d34e3cc..b815c5d 100644
--- a/modules/clients/src/test/resources/spring-cache.xml
+++ b/modules/clients/src/test/resources/spring-cache.xml
@@ -99,8 +99,8 @@
                     -->
                     <property name="backups" value="1"/>
 
-                    <!-- Set synchronous preloading (default is asynchronous). -->
-                    <property name="preloadMode" value="SYNC"/>
+                    <!-- Set synchronous rebalancing (default is asynchronous). -->
+                    <property name="rebalanceMode" value="SYNC"/>
                 </bean>
 
                 <!--
@@ -121,8 +121,8 @@
                     <!-- REPLICATED cache mode. -->
                     <property name="cacheMode" value="REPLICATED"/>
 
-                    <!-- Set synchronous preloading (default is asynchronous). -->
-                    <property name="preloadMode" value="SYNC"/>
+                    <!-- Set synchronous rebalancing (default is asynchronous). -->
+                    <property name="rebalanceMode" value="SYNC"/>
 
                     <!-- Initial cache size. -->
                     <property name="startSize" value="150000"/>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/cache/CachePreloadMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CachePreloadMode.java b/modules/core/src/main/java/org/apache/ignite/cache/CachePreloadMode.java
deleted file mode 100644
index 522bd32..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/CachePreloadMode.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.cache;
-
-import org.jetbrains.annotations.*;
-
-/**
- * Cache preload mode. When preloading is enabled (i.e. has value other than {@link #NONE}), distributed caches
- * will attempt to preload all necessary values from other grid nodes. This enumeration is used to configure
- * preloading via {@link org.apache.ignite.configuration.CacheConfiguration#getPreloadMode()} configuration property. If not configured
- * explicitly, then {@link org.apache.ignite.configuration.CacheConfiguration#DFLT_PRELOAD_MODE} is used.
- * <p>
- * Replicated caches will try to load the full set of cache entries from other nodes (or as defined by
- * pluggable {@link org.apache.ignite.cache.affinity.CacheAffinityFunction}), while partitioned caches will only load the entries for which
- * current node is primary or back up.
- * <p>
- * Note that preload mode only makes sense for {@link CacheMode#REPLICATED} and {@link CacheMode#PARTITIONED}
- * caches. Caches with {@link CacheMode#LOCAL} mode are local by definition and therefore cannot preload
- * any values from neighboring nodes.
- */
-public enum CachePreloadMode {
-    /**
-     * Synchronous preload mode. Distributed caches will not start until all necessary data
-     * is loaded from other available grid nodes.
-     */
-    SYNC,
-
-    /**
-     * Asynchronous preload mode. Distributed caches will start immediately and will load all necessary
-     * data from other available grid nodes in the background.
-     */
-    ASYNC,
-
-    /**
-     * In this mode no preloading will take place which means that caches will be either loaded on
-     * demand from persistent store whenever data is accessed, or will be populated explicitly.
-     */
-    NONE;
-
-    /** Enumerated values. */
-    private static final CachePreloadMode[] VALS = values();
-
-    /**
-     * Efficiently gets enumerated value from its ordinal.
-     *
-     * @param ord Ordinal value.
-     * @return Enumerated value or {@code null} if ordinal out of range.
-     */
-    @Nullable public static CachePreloadMode fromOrdinal(int ord) {
-        return ord >= 0 && ord < VALS.length ? VALS[ord] : null;
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/cache/CacheRebalanceMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheRebalanceMode.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheRebalanceMode.java
new file mode 100644
index 0000000..90d9ba4
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheRebalanceMode.java
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.cache;
+
+import org.jetbrains.annotations.*;
+
+/**
+ * Cache rebalance mode. When rebalancing is enabled (i.e. has value other than {@link #NONE}), distributed caches
+ * will attempt to rebalance all necessary values from other grid nodes. This enumeration is used to configure
+ * rebalancing via {@link org.apache.ignite.configuration.CacheConfiguration#getRebalanceMode()} configuration property. If not configured
+ * explicitly, then {@link org.apache.ignite.configuration.CacheConfiguration#DFLT_REBALANCE_MODE} is used.
+ * <p>
+ * Replicated caches will try to load the full set of cache entries from other nodes (or as defined by
+ * pluggable {@link org.apache.ignite.cache.affinity.CacheAffinityFunction}), while partitioned caches will only load the entries for which
+ * current node is primary or back up.
+ * <p>
+ * Note that rebalance mode only makes sense for {@link CacheMode#REPLICATED} and {@link CacheMode#PARTITIONED}
+ * caches. Caches with {@link CacheMode#LOCAL} mode are local by definition and therefore cannot rebalance
+ * any values from neighboring nodes.
+ */
+public enum CacheRebalanceMode {
+    /**
+     * Synchronous rebalance mode. Distributed caches will not start until all necessary data
+     * is loaded from other available grid nodes.
+     */
+    SYNC,
+
+    /**
+     * Asynchronous rebalance mode. Distributed caches will start immediately and will load all necessary
+     * data from other available grid nodes in the background.
+     */
+    ASYNC,
+
+    /**
+     * In this mode no rebalancing will take place which means that caches will be either loaded on
+     * demand from persistent store whenever data is accessed, or will be populated explicitly.
+     */
+    NONE;
+
+    /** Enumerated values. */
+    private static final CacheRebalanceMode[] VALS = values();
+
+    /**
+     * Efficiently gets enumerated value from its ordinal.
+     *
+     * @param ord Ordinal value.
+     * @return Enumerated value or {@code null} if ordinal out of range.
+     */
+    @Nullable public static CacheRebalanceMode fromOrdinal(int ord) {
+        return ord >= 0 && ord < VALS.length ? VALS[ord] : null;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/cache/GridCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/GridCache.java b/modules/core/src/main/java/org/apache/ignite/cache/GridCache.java
index 8bbea1f..ee1762e 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/GridCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/GridCache.java
@@ -19,11 +19,9 @@ package org.apache.ignite.cache;
 
 import org.apache.ignite.*;
 import org.apache.ignite.cache.affinity.*;
-import org.apache.ignite.cache.store.*;
 import org.apache.ignite.configuration.*;
 import org.apache.ignite.internal.*;
 import org.apache.ignite.internal.processors.cache.*;
-import org.apache.ignite.lang.*;
 import org.apache.ignite.mxbean.*;
 import org.apache.ignite.transactions.*;
 import org.jetbrains.annotations.*;
@@ -201,23 +199,23 @@ public interface GridCache<K, V> extends CacheProjection<K, V> {
 
     /**
      * Forces this cache node to re-balance its partitions. This method is usually used when
-     * {@link CacheConfiguration#getPreloadPartitionedDelay()} configuration parameter has non-zero value.
+     * {@link CacheConfiguration#getRebalancePartitionedDelay()} configuration parameter has non-zero value.
      * When many nodes are started or stopped almost concurrently, it is more efficient to delay
-     * preloading until the node topology is stable to make sure that no redundant re-partitioning
+     * rebalancing until the node topology is stable to make sure that no redundant re-partitioning
      * happens.
      * <p>
      * In case of{@link CacheMode#PARTITIONED} caches, for better efficiency user should
      * usually make sure that new nodes get placed on the same place of consistent hash ring as
      * the left nodes, and that nodes are restarted before
-     * {@link CacheConfiguration#getPreloadPartitionedDelay() preloadDelay} expires. To place nodes
+     * {@link CacheConfiguration#getRebalancePartitionedDelay() rebalanceDelay} expires. To place nodes
      * on the same place in consistent hash ring, use
      * {@link org.apache.ignite.cache.affinity.consistenthash.CacheConsistentHashAffinityFunction#setHashIdResolver(org.apache.ignite.cache.affinity.CacheAffinityNodeHashResolver)} to make sure that
      * a node maps to the same hash ID if re-started.
      * <p>
-     * See {@link org.apache.ignite.configuration.CacheConfiguration#getPreloadPartitionedDelay()} for more information on how to configure
-     * preload re-partition delay.
+     * See {@link org.apache.ignite.configuration.CacheConfiguration#getRebalancePartitionedDelay()} for more information on how to configure
+     * rebalance re-partition delay.
      * <p>
-     * @return Future that will be completed when preloading is finished.
+     * @return Future that will be completed when rebalancing is finished.
      */
     public IgniteInternalFuture<?> forceRepartition();
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
index 57583d4..f8186bc 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
@@ -43,14 +43,14 @@ import java.util.*;
  */
 @SuppressWarnings("RedundantFieldInitialization")
 public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
-    /** Default size of preload thread pool. */
-    public static final int DFLT_PRELOAD_THREAD_POOL_SIZE = 2;
+    /** Default size of rebalance thread pool. */
+    public static final int DFLT_REBALANCE_THREAD_POOL_SIZE = 2;
 
-    /** Default preload timeout (ms).*/
-    public static final long DFLT_PRELOAD_TIMEOUT = 10000;
+    /** Default rebalance timeout (ms).*/
+    public static final long DFLT_REBALANCE_TIMEOUT = 10000;
 
-    /** Time in milliseconds to wait between preload messages to avoid overloading CPU. */
-    public static final long DFLT_PRELOAD_THROTTLE = 0;
+    /** Time in milliseconds to wait between rebalance messages to avoid overloading CPU. */
+    public static final long DFLT_REBALANCE_THROTTLE = 0;
 
     /**
      * Default time to live. The value is <tt>0</tt> which means that
@@ -91,11 +91,11 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     /** Default value for 'storeValueBytes' flag indicating if value bytes should be stored. */
     public static final boolean DFLT_STORE_VALUE_BYTES = true;
 
-    /** Default preload mode for distributed cache. */
-    public static final CachePreloadMode DFLT_PRELOAD_MODE = CachePreloadMode.ASYNC;
+    /** Default rebalance mode for distributed cache. */
+    public static final CacheRebalanceMode DFLT_REBALANCE_MODE = CacheRebalanceMode.ASYNC;
 
-    /** Default preload batch size in bytes. */
-    public static final int DFLT_PRELOAD_BATCH_SIZE = 512 * 1024; // 512K
+    /** Default rebalance batch size in bytes. */
+    public static final int DFLT_REBALANCE_BATCH_SIZE = 512 * 1024; // 512K
 
     /** Default maximum eviction queue ratio. */
     public static final float DFLT_MAX_EVICTION_OVERFLOW_RATIO = 10;
@@ -163,11 +163,11 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     /** Cache name. */
     private String name;
 
-    /** Preload thread pool size. */
-    private int preloadPoolSize = DFLT_PRELOAD_THREAD_POOL_SIZE;
+    /** Rebalance thread pool size. */
+    private int rebalancePoolSize = DFLT_REBALANCE_THREAD_POOL_SIZE;
 
-    /** Preload timeout. */
-    private long preloadTimeout = DFLT_PRELOAD_TIMEOUT;
+    /** Rebalance timeout. */
+    private long rebalanceTimeout = DFLT_REBALANCE_TIMEOUT;
 
     /** Default time to live for cache entries. */
     private long ttl = DFLT_TIME_TO_LIVE;
@@ -250,14 +250,14 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     /** Name of class implementing GridCacheTmLookup. */
     private String tmLookupClsName;
 
-    /** Distributed cache preload mode. */
-    private CachePreloadMode preloadMode = DFLT_PRELOAD_MODE;
+    /** Distributed cache rebalance mode. */
+    private CacheRebalanceMode rebalanceMode = DFLT_REBALANCE_MODE;
 
-    /** Cache preload order. */
-    private int preloadOrder;
+    /** Cache rebalance order. */
+    private int rebalanceOrder;
 
-    /** Preload batch size. */
-    private int preloadBatchSize = DFLT_PRELOAD_BATCH_SIZE;
+    /** Rebalance batch size. */
+    private int rebalanceBatchSize = DFLT_REBALANCE_BATCH_SIZE;
 
     /** Off-heap memory size. */
     private long offHeapMaxMem = DFLT_OFFHEAP_MEMORY;
@@ -299,10 +299,10 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     private String indexingSpiName;
 
     /** */
-    private long preloadDelay;
+    private long rebalanceDelay;
 
     /** */
-    private long preloadThrottle = DFLT_PRELOAD_THROTTLE;
+    private long rebalanceThrottle = DFLT_REBALANCE_THROTTLE;
 
     /** */
     private CacheInterceptor<?, ?> interceptor;
@@ -376,13 +376,13 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
         name = cc.getName();
         nearStartSize = cc.getNearStartSize();
         nearEvictPlc = cc.getNearEvictionPolicy();
-        preloadMode = cc.getPreloadMode();
-        preloadBatchSize = cc.getPreloadBatchSize();
-        preloadDelay = cc.getPreloadPartitionedDelay();
-        preloadOrder = cc.getPreloadOrder();
-        preloadPoolSize = cc.getPreloadThreadPoolSize();
-        preloadTimeout = cc.getPreloadTimeout();
-        preloadThrottle = cc.getPreloadThrottle();
+        rebalanceMode = cc.getRebalanceMode();
+        rebalanceBatchSize = cc.getRebalanceBatchSize();
+        rebalanceDelay = cc.getRebalancePartitionedDelay();
+        rebalanceOrder = cc.getRebalanceOrder();
+        rebalancePoolSize = cc.getRebalanceThreadPoolSize();
+        rebalanceTimeout = cc.getRebalanceTimeout();
+        rebalanceThrottle = cc.getRebalanceThrottle();
         qryCfg = cc.getQueryConfiguration();
         qryIdxEnabled = cc.isQueryIndexEnabled();
         readFromBackup = cc.isReadFromBackup();
@@ -1033,73 +1033,73 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     }
 
     /**
-     * Sets cache preload mode.
+     * Sets cache rebalance mode.
      *
-     * @param preloadMode Preload mode.
+     * @param rebalanceMode Rebalance mode.
      */
-    public void setPreloadMode(CachePreloadMode preloadMode) {
-        this.preloadMode = preloadMode;
+    public void setRebalanceMode(CacheRebalanceMode rebalanceMode) {
+        this.rebalanceMode = rebalanceMode;
     }
 
     /**
-     * Gets preload mode for distributed cache.
+     * Gets rebalance mode for distributed cache.
      * <p>
-     * Default is defined by {@link #DFLT_PRELOAD_MODE}.
+     * Default is defined by {@link #DFLT_REBALANCE_MODE}.
      *
-     * @return Preload mode.
+     * @return Rebalance mode.
      */
-    public CachePreloadMode getPreloadMode() {
-        return preloadMode;
+    public CacheRebalanceMode getRebalanceMode() {
+        return rebalanceMode;
     }
 
     /**
-     * Gets cache preload order. Preload order can be set to non-zero value for caches with
-     * {@link CachePreloadMode#SYNC SYNC} or {@link CachePreloadMode#ASYNC ASYNC} preload modes only.
+     * Gets cache rebalance order. Rebalance order can be set to non-zero value for caches with
+     * {@link CacheRebalanceMode#SYNC SYNC} or {@link CacheRebalanceMode#ASYNC ASYNC} rebalance modes only.
      * <p/>
-     * If cache preload order is positive, preloading for this cache will be started only when preloading for
-     * all caches with smaller preload order (except caches with preload order {@code 0}) will be completed.
+     * If cache rebalance order is positive, rebalancing for this cache will be started only when rebalancing for
+     * all caches with smaller rebalance order (except caches with rebalance order {@code 0}) will be completed.
      * <p/>
      * Note that cache with order {@code 0} does not participate in ordering. This means that cache with
-     * preload order {@code 1} will never wait for any other caches. All caches with order {@code 0} will
-     * be preloaded right away concurrently with each other and ordered preload processes.
+     * rebalance order {@code 1} will never wait for any other caches. All caches with order {@code 0} will
+     * be rebalanced right away concurrently with each other and ordered rebalance processes.
      * <p/>
-     * If not set, cache order is 0, i.e. preloading is not ordered.
+     * If not set, cache order is 0, i.e. rebalancing is not ordered.
      *
-     * @return Cache preload order.
+     * @return Cache rebalance order.
      */
-    public int getPreloadOrder() {
-        return preloadOrder;
+    public int getRebalanceOrder() {
+        return rebalanceOrder;
     }
 
     /**
-     * Sets cache preload order.
+     * Sets cache rebalance order.
      *
-     * @param preloadOrder Cache preload order.
-     * @see #getPreloadOrder()
+     * @param rebalanceOrder Cache rebalance order.
+     * @see #getRebalanceOrder()
      */
-    public void setPreloadOrder(int preloadOrder) {
-        this.preloadOrder = preloadOrder;
+    public void setRebalanceOrder(int rebalanceOrder) {
+        this.rebalanceOrder = rebalanceOrder;
     }
 
     /**
-     * Gets size (in number bytes) to be loaded within a single preload message.
-     * Preloading algorithm will split total data set on every node into multiple
+     * Gets size (in number bytes) to be loaded within a single rebalance message.
+     * Rebalancing algorithm will split total data set on every node into multiple
      * batches prior to sending data. Default value is defined by
-     * {@link #DFLT_PRELOAD_BATCH_SIZE}.
+     * {@link #DFLT_REBALANCE_BATCH_SIZE}.
      *
-     * @return Size in bytes of a single preload message.
+     * @return Size in bytes of a single rebalance message.
      */
-    public int getPreloadBatchSize() {
-        return preloadBatchSize;
+    public int getRebalanceBatchSize() {
+        return rebalanceBatchSize;
     }
 
     /**
-     * Sets preload batch size.
+     * Sets rebalance batch size.
      *
-     * @param preloadBatchSize Preload batch size.
+     * @param rebalanceBatchSize Rebalance batch size.
      */
-    public void setPreloadBatchSize(int preloadBatchSize) {
-        this.preloadBatchSize = preloadBatchSize;
+    public void setRebalanceBatchSize(int rebalanceBatchSize) {
+        this.rebalanceBatchSize = rebalanceBatchSize;
     }
 
     /**
@@ -1292,54 +1292,54 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     }
 
     /**
-     * Gets size of preloading thread pool. Note that size serves as a hint and implementation
-     * may create more threads for preloading than specified here (but never less threads).
+     * Gets size of rebalancing thread pool. Note that size serves as a hint and implementation
+     * may create more threads for rebalancing than specified here (but never less threads).
      * <p>
-     * Default value is {@link #DFLT_PRELOAD_THREAD_POOL_SIZE}.
+     * Default value is {@link #DFLT_REBALANCE_THREAD_POOL_SIZE}.
      *
-     * @return Size of preloading thread pool.
+     * @return Size of rebalancing thread pool.
      */
-    public int getPreloadThreadPoolSize() {
-        return preloadPoolSize;
+    public int getRebalanceThreadPoolSize() {
+        return rebalancePoolSize;
     }
 
     /**
-     * Sets size of preloading thread pool. Note that size serves as a hint and implementation may create more threads
-     * for preloading than specified here (but never less threads).
+     * Sets size of rebalancing thread pool. Note that size serves as a hint and implementation may create more threads
+     * for rebalancing than specified here (but never less threads).
      *
-     * @param preloadPoolSize Size of preloading thread pool.
+     * @param rebalancePoolSize Size of rebalancing thread pool.
      */
-    public void setPreloadThreadPoolSize(int preloadPoolSize) {
-        this.preloadPoolSize = preloadPoolSize;
+    public void setRebalanceThreadPoolSize(int rebalancePoolSize) {
+        this.rebalancePoolSize = rebalancePoolSize;
     }
 
     /**
-     * Gets preload timeout (ms).
+     * Gets rebalance timeout (ms).
      * <p>
-     * Default value is {@link #DFLT_PRELOAD_TIMEOUT}.
+     * Default value is {@link #DFLT_REBALANCE_TIMEOUT}.
      *
-     * @return Preload timeout (ms).
+     * @return Rebalance timeout (ms).
      */
-    public long getPreloadTimeout() {
-        return preloadTimeout;
+    public long getRebalanceTimeout() {
+        return rebalanceTimeout;
     }
 
     /**
-     * Sets preload timeout (ms).
+     * Sets rebalance timeout (ms).
      *
-     * @param preloadTimeout Preload timeout (ms).
+     * @param rebalanceTimeout Rebalance timeout (ms).
      */
-    public void setPreloadTimeout(long preloadTimeout) {
-        this.preloadTimeout = preloadTimeout;
+    public void setRebalanceTimeout(long rebalanceTimeout) {
+        this.rebalanceTimeout = rebalanceTimeout;
     }
 
     /**
-     * Gets delay in milliseconds upon a node joining or leaving topology (or crash) after which preloading
-     * should be started automatically. Preloading should be delayed if you plan to restart nodes
+     * Gets delay in milliseconds upon a node joining or leaving topology (or crash) after which rebalancing
+     * should be started automatically. Rebalancing should be delayed if you plan to restart nodes
      * after they leave topology, or if you plan to start multiple nodes at once or one after another
-     * and don't want to repartition and preload until all nodes are started.
+     * and don't want to repartition and rebalance until all nodes are started.
      * <p>
-     * Delayed preloading is applied to {@link CacheMode#PARTITIONED} caches only.
+     * Delayed rebalancing is applied to {@link CacheMode#PARTITIONED} caches only.
      * For better efficiency user should usually make sure that new nodes get placed on
      * the same place of consistent hash ring as the left nodes, and that nodes are
      * restarted before this delay expires. To place nodes on the same place in consistent hash ring,
@@ -1347,59 +1347,59 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      * to make sure that a node maps to the same hash ID event if restarted. As an example,
      * node IP address and port combination may be used in this case.
      * <p>
-     * Default value is {@code 0} which means that repartitioning and preloading will start
-     * immediately upon node leaving topology. If {@code -1} is returned, then preloading
+     * Default value is {@code 0} which means that repartitioning and rebalancing will start
+     * immediately upon node leaving topology. If {@code -1} is returned, then rebalancing
      * will only be started manually by calling {@link GridCache#forceRepartition()} method or
      * from management console.
      *
-     * @return Preloading delay, {@code 0} to start preloading immediately, {@code -1} to
-     *      start preloading manually, or positive value to specify delay in milliseconds
-     *      after which preloading should start automatically.
+     * @return Rebalancing delay, {@code 0} to start rebalancing immediately, {@code -1} to
+     *      start rebalancing manually, or positive value to specify delay in milliseconds
+     *      after which rebalancing should start automatically.
      */
-    public long getPreloadPartitionedDelay() {
-        return preloadDelay;
+    public long getRebalancePartitionedDelay() {
+        return rebalanceDelay;
     }
 
     /**
-     * Sets preload delay (see {@link #getPreloadPartitionedDelay()} for more information).
+     * Sets rebalance delay (see {@link #getRebalancePartitionedDelay()} for more information).
      *
-     * @param preloadDelay Preload delay to set.
+     * @param rebalanceDelay Rebalance delay to set.
      */
-    public void setPreloadPartitionedDelay(long preloadDelay) {
-        this.preloadDelay = preloadDelay;
+    public void setRebalancePartitionedDelay(long rebalanceDelay) {
+        this.rebalanceDelay = rebalanceDelay;
     }
 
     /**
-     * Time in milliseconds to wait between preload messages to avoid overloading of CPU or network.
-     * When preloading large data sets, the CPU or network can get over-consumed with preloading messages,
+     * Time in milliseconds to wait between rebalance messages to avoid overloading of CPU or network.
+     * When rebalancing large data sets, the CPU or network can get over-consumed with rebalancing messages,
      * which consecutively may slow down the application performance. This parameter helps tune
-     * the amount of time to wait between preload messages to make sure that preloading process
+     * the amount of time to wait between rebalance messages to make sure that rebalancing process
      * does not have any negative performance impact. Note that application will continue to work
-     * properly while preloading is still in progress.
+     * properly while rebalancing is still in progress.
      * <p>
      * Value of {@code 0} means that throttling is disabled. By default throttling is disabled -
-     * the default is defined by {@link #DFLT_PRELOAD_THROTTLE} constant.
+     * the default is defined by {@link #DFLT_REBALANCE_THROTTLE} constant.
      *
-     * @return Time in milliseconds to wait between preload messages to avoid overloading of CPU,
+     * @return Time in milliseconds to wait between rebalance messages to avoid overloading of CPU,
      *      {@code 0} to disable throttling.
      */
-    public long getPreloadThrottle() {
-        return preloadThrottle;
+    public long getRebalanceThrottle() {
+        return rebalanceThrottle;
     }
 
     /**
-     * Time in milliseconds to wait between preload messages to avoid overloading of CPU or network. When preloading
-     * large data sets, the CPU or network can get over-consumed with preloading messages, which consecutively may slow
-     * down the application performance. This parameter helps tune the amount of time to wait between preload messages
-     * to make sure that preloading process does not have any negative performance impact. Note that application will
-     * continue to work properly while preloading is still in progress. <p> Value of {@code 0} means that throttling is
-     * disabled. By default throttling is disabled - the default is defined by {@link #DFLT_PRELOAD_THROTTLE} constant.
+     * Time in milliseconds to wait between rebalance messages to avoid overloading of CPU or network. When rebalancing
+     * large data sets, the CPU or network can get over-consumed with rebalancing messages, which consecutively may slow
+     * down the application performance. This parameter helps tune the amount of time to wait between rebalance messages
+     * to make sure that rebalancing process does not have any negative performance impact. Note that application will
+     * continue to work properly while rebalancing is still in progress. <p> Value of {@code 0} means that throttling is
+     * disabled. By default throttling is disabled - the default is defined by {@link #DFLT_REBALANCE_THROTTLE} constant.
      *
-     * @param preloadThrottle Time in milliseconds to wait between preload messages to avoid overloading of CPU, {@code
-     * 0} to disable throttling.
+     * @param rebalanceThrottle Time in milliseconds to wait between rebalance messages to avoid overloading of CPU, 
+     * {@code 0} to disable throttling.
      */
-    public void setPreloadThrottle(long preloadThrottle) {
-        this.preloadThrottle = preloadThrottle;
+    public void setRebalanceThrottle(long rebalanceThrottle) {
+        this.rebalanceThrottle = rebalanceThrottle;
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/events/CachePreloadingEvent.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/events/CachePreloadingEvent.java b/modules/core/src/main/java/org/apache/ignite/events/CachePreloadingEvent.java
deleted file mode 100644
index 25ec68a..0000000
--- a/modules/core/src/main/java/org/apache/ignite/events/CachePreloadingEvent.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.events;
-
-import org.apache.ignite.cluster.*;
-import org.apache.ignite.internal.util.typedef.internal.*;
-
-/**
- * In-memory database (cache) preloading event. Preload event happens every time there is a change
- * in grid topology, which means that a node has either joined or left the grid.
- * <p>
- * Grid events are used for notification about what happens within the grid. Note that by
- * design Ignite keeps all events generated on the local node locally and it provides
- * APIs for performing a distributed queries across multiple nodes:
- * <ul>
- *      <li>
- *          {@link org.apache.ignite.IgniteEvents#remoteQuery(org.apache.ignite.lang.IgnitePredicate, long, int...)} -
- *          asynchronously querying events occurred on the nodes specified, including remote nodes.
- *      </li>
- *      <li>
- *          {@link org.apache.ignite.IgniteEvents#localQuery(org.apache.ignite.lang.IgnitePredicate, int...)} -
- *          querying only local events stored on this local node.
- *      </li>
- *      <li>
- *          {@link org.apache.ignite.IgniteEvents#localListen(org.apache.ignite.lang.IgnitePredicate, int...)} -
- *          listening to local grid events (events from remote nodes not included).
- *      </li>
- * </ul>
- * User can also wait for events using method {@link org.apache.ignite.IgniteEvents#waitForLocal(org.apache.ignite.lang.IgnitePredicate, int...)}.
- * <h1 class="header">Events and Performance</h1>
- * Note that by default all events in Ignite are enabled and therefore generated and stored
- * by whatever event storage SPI is configured. Ignite can and often does generate thousands events per seconds
- * under the load and therefore it creates a significant additional load on the system. If these events are
- * not needed by the application this load is unnecessary and leads to significant performance degradation.
- * <p>
- * It is <b>highly recommended</b> to enable only those events that your application logic requires
- * by using {@link org.apache.ignite.configuration.IgniteConfiguration#getIncludeEventTypes()} method in Ignite configuration. Note that certain
- * events are required for Ignite's internal operations and such events will still be generated but not stored by
- * event storage SPI if they are disabled in Ignite configuration.
- * @see EventType#EVT_CACHE_PRELOAD_PART_LOADED
- * @see EventType#EVT_CACHE_PRELOAD_PART_UNLOADED
- * @see EventType#EVT_CACHE_PRELOAD_STARTED
- * @see EventType#EVT_CACHE_PRELOAD_STOPPED
- */
-public class CachePreloadingEvent extends EventAdapter {
-    /** */
-    private static final long serialVersionUID = 0L;
-
-    /** Cache name. */
-    private String cacheName;
-
-    /** Partition for the event. */
-    private int part;
-
-    /** Discovery node. */
-    private ClusterNode discoNode;
-
-    /** Discovery event type. */
-    private int discoEvtType;
-
-    /** Discovery event time. */
-    private long discoTs;
-
-    /**
-     * Constructs cache event.
-     *
-     * @param cacheName Cache name.
-     * @param node Event node.
-     * @param msg Event message.
-     * @param type Event type.
-     * @param part Partition for the event (usually the partition the key belongs to).
-     * @param discoNode Node that triggered this preloading event.
-     * @param discoEvtType Discovery event type that triggered this preloading event.
-     * @param discoTs Timestamp of discovery event that triggered this preloading event.
-     */
-    public CachePreloadingEvent(String cacheName, ClusterNode node, String msg, int type, int part,
-        ClusterNode discoNode, int discoEvtType, long discoTs) {
-        super(node, msg, type);
-        this.cacheName = cacheName;
-        this.part = part;
-        this.discoNode = discoNode;
-        this.discoEvtType = discoEvtType;
-        this.discoTs = discoTs;
-    }
-
-    /**
-     * Gets cache name.
-     *
-     * @return Cache name.
-     */
-    public String cacheName() {
-        return cacheName;
-    }
-
-    /**
-     * Gets partition for the event.
-     *
-     * @return Partition for the event.
-     */
-    public int partition() {
-        return part;
-    }
-
-    /**
-     * Gets shadow of the node that triggered this preloading event.
-     *
-     * @return Shadow of the node that triggered this preloading event.
-     */
-    public ClusterNode discoveryNode() {
-        return discoNode;
-    }
-
-    /**
-     * Gets type of discovery event that triggered this preloading event.
-     *
-     * @return Type of discovery event that triggered this preloading event.
-     * @see DiscoveryEvent#type()
-     */
-    public int discoveryEventType() {
-        return discoEvtType;
-    }
-
-    /**
-     * Gets name of discovery event that triggered this preloading event.
-     *
-     * @return Name of discovery event that triggered this preloading event.
-     * @see DiscoveryEvent#name()
-     */
-    public String discoveryEventName() {
-        return U.gridEventName(discoEvtType);
-    }
-
-    /**
-     * Gets timestamp of discovery event that caused this preloading event.
-     *
-     * @return Timestamp of discovery event that caused this preloading event.
-     */
-    public long discoveryTimestamp() {
-        return discoTs;
-    }
-
-    /** {@inheritDoc} */
-    @Override public String shortDisplay() {
-        return name() + ": cache=" + CU.mask(cacheName) + ", cause=" +
-            discoveryEventName();
-    }
-
-    /** {@inheritDoc} */
-    @Override public String toString() {
-        return S.toString(CachePreloadingEvent.class, this,
-            "discoEvtName", discoveryEventName(),
-            "nodeId8", U.id8(node().id()),
-            "msg", message(),
-            "type", name(),
-            "tstamp", timestamp());
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/events/CacheRebalancingEvent.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/events/CacheRebalancingEvent.java b/modules/core/src/main/java/org/apache/ignite/events/CacheRebalancingEvent.java
new file mode 100644
index 0000000..661c2b5
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/events/CacheRebalancingEvent.java
@@ -0,0 +1,172 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.events;
+
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+
+/**
+ * In-memory database (cache) rebalancing event. Rebalance event happens every time there is a change
+ * in grid topology, which means that a node has either joined or left the grid.
+ * <p>
+ * Grid events are used for notification about what happens within the grid. Note that by
+ * design Ignite keeps all events generated on the local node locally and it provides
+ * APIs for performing a distributed queries across multiple nodes:
+ * <ul>
+ *      <li>
+ *          {@link org.apache.ignite.IgniteEvents#remoteQuery(org.apache.ignite.lang.IgnitePredicate, long, int...)} -
+ *          asynchronously querying events occurred on the nodes specified, including remote nodes.
+ *      </li>
+ *      <li>
+ *          {@link org.apache.ignite.IgniteEvents#localQuery(org.apache.ignite.lang.IgnitePredicate, int...)} -
+ *          querying only local events stored on this local node.
+ *      </li>
+ *      <li>
+ *          {@link org.apache.ignite.IgniteEvents#localListen(org.apache.ignite.lang.IgnitePredicate, int...)} -
+ *          listening to local grid events (events from remote nodes not included).
+ *      </li>
+ * </ul>
+ * User can also wait for events using method {@link org.apache.ignite.IgniteEvents#waitForLocal(org.apache.ignite.lang.IgnitePredicate, int...)}.
+ * <h1 class="header">Events and Performance</h1>
+ * Note that by default all events in Ignite are enabled and therefore generated and stored
+ * by whatever event storage SPI is configured. Ignite can and often does generate thousands events per seconds
+ * under the load and therefore it creates a significant additional load on the system. If these events are
+ * not needed by the application this load is unnecessary and leads to significant performance degradation.
+ * <p>
+ * It is <b>highly recommended</b> to enable only those events that your application logic requires
+ * by using {@link org.apache.ignite.configuration.IgniteConfiguration#getIncludeEventTypes()} method in Ignite configuration. Note that certain
+ * events are required for Ignite's internal operations and such events will still be generated but not stored by
+ * event storage SPI if they are disabled in Ignite configuration.
+ * @see EventType#EVT_CACHE_REBALANCE_PART_LOADED
+ * @see EventType#EVT_CACHE_REBALANCE_PART_UNLOADED
+ * @see EventType#EVT_CACHE_REBALANCE_STARTED
+ * @see EventType#EVT_CACHE_REBALANCE_STOPPED
+ */
+public class CacheRebalancingEvent extends EventAdapter {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Cache name. */
+    private String cacheName;
+
+    /** Partition for the event. */
+    private int part;
+
+    /** Discovery node. */
+    private ClusterNode discoNode;
+
+    /** Discovery event type. */
+    private int discoEvtType;
+
+    /** Discovery event time. */
+    private long discoTs;
+
+    /**
+     * Constructs cache event.
+     *
+     * @param cacheName Cache name.
+     * @param node Event node.
+     * @param msg Event message.
+     * @param type Event type.
+     * @param part Partition for the event (usually the partition the key belongs to).
+     * @param discoNode Node that triggered this rebalancing event.
+     * @param discoEvtType Discovery event type that triggered this rebalancing event.
+     * @param discoTs Timestamp of discovery event that triggered this rebalancing event.
+     */
+    public CacheRebalancingEvent(String cacheName, ClusterNode node, String msg, int type, int part,
+        ClusterNode discoNode, int discoEvtType, long discoTs) {
+        super(node, msg, type);
+        this.cacheName = cacheName;
+        this.part = part;
+        this.discoNode = discoNode;
+        this.discoEvtType = discoEvtType;
+        this.discoTs = discoTs;
+    }
+
+    /**
+     * Gets cache name.
+     *
+     * @return Cache name.
+     */
+    public String cacheName() {
+        return cacheName;
+    }
+
+    /**
+     * Gets partition for the event.
+     *
+     * @return Partition for the event.
+     */
+    public int partition() {
+        return part;
+    }
+
+    /**
+     * Gets shadow of the node that triggered this rebalancing event.
+     *
+     * @return Shadow of the node that triggered this rebalancing event.
+     */
+    public ClusterNode discoveryNode() {
+        return discoNode;
+    }
+
+    /**
+     * Gets type of discovery event that triggered this rebalancing event.
+     *
+     * @return Type of discovery event that triggered this rebalancing event.
+     * @see DiscoveryEvent#type()
+     */
+    public int discoveryEventType() {
+        return discoEvtType;
+    }
+
+    /**
+     * Gets name of discovery event that triggered this rebalancing event.
+     *
+     * @return Name of discovery event that triggered this rebalancing event.
+     * @see DiscoveryEvent#name()
+     */
+    public String discoveryEventName() {
+        return U.gridEventName(discoEvtType);
+    }
+
+    /**
+     * Gets timestamp of discovery event that caused this rebalancing event.
+     *
+     * @return Timestamp of discovery event that caused this rebalancing event.
+     */
+    public long discoveryTimestamp() {
+        return discoTs;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String shortDisplay() {
+        return name() + ": cache=" + CU.mask(cacheName) + ", cause=" +
+            discoveryEventName();
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(CacheRebalancingEvent.class, this,
+            "discoEvtName", discoveryEventName(),
+            "nodeId8", U.id8(node().id()),
+            "msg", message(),
+            "type", name(),
+            "tstamp", timestamp());
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/events/Event.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/events/Event.java b/modules/core/src/main/java/org/apache/ignite/events/Event.java
index b47bd54..3951677 100644
--- a/modules/core/src/main/java/org/apache/ignite/events/Event.java
+++ b/modules/core/src/main/java/org/apache/ignite/events/Event.java
@@ -75,7 +75,7 @@ import java.io.*;
  * </ul>
  * @see JobEvent
  * @see CacheEvent
- * @see CachePreloadingEvent
+ * @see CacheRebalancingEvent
  * @see SwapSpaceEvent
  * @see CheckpointEvent
  * @see DeploymentEvent

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/events/EventType.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/events/EventType.java b/modules/core/src/main/java/org/apache/ignite/events/EventType.java
index 5821da5..2ce47eb 100644
--- a/modules/core/src/main/java/org/apache/ignite/events/EventType.java
+++ b/modules/core/src/main/java/org/apache/ignite/events/EventType.java
@@ -17,10 +17,8 @@
 
 package org.apache.ignite.events;
 
-import org.apache.ignite.internal.managers.discovery.*;
 import org.apache.ignite.internal.util.typedef.internal.*;
 
-import java.io.*;
 import java.util.*;
 
 /**
@@ -39,7 +37,7 @@ import java.util.*;
  * <li>{@link #EVTS_JOB_EXECUTION}</li>
  * <li>{@link #EVTS_TASK_EXECUTION}</li>
  * <li>{@link #EVTS_CACHE}</li>
- * <li>{@link #EVTS_CACHE_PRELOAD}</li>
+ * <li>{@link #EVTS_CACHE_REBALANCE}</li>
  * <li>{@link #EVTS_CACHE_QUERY}</li>
  * <li>{@link #EVTS_SWAPSPACE}</li>
  * </ul>
@@ -556,24 +554,24 @@ public interface EventType {
     public static final int EVT_CACHE_OBJECT_FROM_OFFHEAP = 77;
 
     /**
-     * Built-in event type: cache preload started.
+     * Built-in event type: cache rebalance started.
      * <p>
      * NOTE: all types in range <b>from 1 to 1000 are reserved</b> for
      * internal Ignite events and should not be used by user-defined events.
      *
      * @see SwapSpaceEvent
      */
-    public static final int EVT_CACHE_PRELOAD_STARTED = 80;
+    public static final int EVT_CACHE_REBALANCE_STARTED = 80;
 
     /**
-     * Built-in event type: cache preload stopped.
+     * Built-in event type: cache rebalance stopped.
      * <p>
      * NOTE: all types in range <b>from 1 to 1000 are reserved</b> for
      * internal Ignite events and should not be used by user-defined events.
      *
      * @see SwapSpaceEvent
      */
-    public static final int EVT_CACHE_PRELOAD_STOPPED = 81;
+    public static final int EVT_CACHE_REBALANCE_STOPPED = 81;
 
     /**
      * Built-in event type: cache partition loaded.
@@ -583,7 +581,7 @@ public interface EventType {
      *
      * @see SwapSpaceEvent
      */
-    public static final int EVT_CACHE_PRELOAD_PART_LOADED = 82;
+    public static final int EVT_CACHE_REBALANCE_PART_LOADED = 82;
 
     /**
      * Built-in event type: cache partition unloaded.
@@ -591,15 +589,15 @@ public interface EventType {
      * NOTE: all types in range <b>from 1 to 1000 are reserved</b> for
      * internal Ignite events and should not be used by user-defined events.
      */
-    public static final int EVT_CACHE_PRELOAD_PART_UNLOADED = 83;
+    public static final int EVT_CACHE_REBALANCE_PART_UNLOADED = 83;
 
     /**
-     * Built-in event type: cache entry preloaded.
+     * Built-in event type: cache entry rebalanced.
      * <p>
      * NOTE: all types in range <b>from 1 to 1000 are reserved</b> for
      * internal Ignite events and should not be used by user-defined events.
      */
-    public static final int EVT_CACHE_PRELOAD_OBJECT_LOADED = 84;
+    public static final int EVT_CACHE_REBALANCE_OBJECT_LOADED = 84;
 
     /**
      * Built-in event type: cache entry unloaded.
@@ -607,7 +605,7 @@ public interface EventType {
      * NOTE: all types in range <b>from 1 to 1000 are reserved</b> for
      * internal Ignite events and should not be used by user-defined events.
      */
-    public static final int EVT_CACHE_PRELOAD_OBJECT_UNLOADED = 85;
+    public static final int EVT_CACHE_REBALANCE_OBJECT_UNLOADED = 85;
 
     /**
      * Built-in event type: query executed.
@@ -822,8 +820,8 @@ public interface EventType {
         EVT_TASK_DEPLOY_FAILED,
         EVT_TASK_DEPLOYED,
         EVT_TASK_UNDEPLOYED,
-        EVT_CACHE_PRELOAD_STARTED,
-        EVT_CACHE_PRELOAD_STOPPED
+        EVT_CACHE_REBALANCE_STARTED,
+        EVT_CACHE_REBALANCE_STOPPED
     };
 
     /**
@@ -919,17 +917,17 @@ public interface EventType {
     };
 
     /**
-     * All cache preload events. This array can be directly passed into
+     * All cache rebalance events. This array can be directly passed into
      * {@link org.apache.ignite.IgniteEvents#localListen(org.apache.ignite.lang.IgnitePredicate, int...)} method to
-     * subscribe to all cache preload events.
-     */
-    public static final int[] EVTS_CACHE_PRELOAD = {
-        EVT_CACHE_PRELOAD_STARTED,
-        EVT_CACHE_PRELOAD_STOPPED,
-        EVT_CACHE_PRELOAD_PART_LOADED,
-        EVT_CACHE_PRELOAD_PART_UNLOADED,
-        EVT_CACHE_PRELOAD_OBJECT_LOADED,
-        EVT_CACHE_PRELOAD_OBJECT_UNLOADED
+     * subscribe to all cache rebalance events.
+     */
+    public static final int[] EVTS_CACHE_REBALANCE = {
+        EVT_CACHE_REBALANCE_STARTED,
+        EVT_CACHE_REBALANCE_STOPPED,
+        EVT_CACHE_REBALANCE_PART_LOADED,
+        EVT_CACHE_REBALANCE_PART_UNLOADED,
+        EVT_CACHE_REBALANCE_OBJECT_LOADED,
+        EVT_CACHE_REBALANCE_OBJECT_UNLOADED
     };
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
index 6503ed9..19cfc39 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
@@ -77,7 +77,7 @@ import static org.apache.ignite.IgniteSystemProperties.*;
 import static org.apache.ignite.cache.CacheAtomicityMode.*;
 import static org.apache.ignite.cache.CacheDistributionMode.*;
 import static org.apache.ignite.cache.CacheMode.*;
-import static org.apache.ignite.cache.CachePreloadMode.*;
+import static org.apache.ignite.cache.CacheRebalanceMode.*;
 import static org.apache.ignite.cache.CacheWriteSynchronizationMode.*;
 import static org.apache.ignite.configuration.IgniteConfiguration.*;
 import static org.apache.ignite.internal.IgniteComponentType.*;
@@ -1933,7 +1933,7 @@ public class IgnitionEx {
             cache.setAtomicityMode(TRANSACTIONAL);
             cache.setSwapEnabled(false);
             cache.setQueryIndexEnabled(false);
-            cache.setPreloadMode(SYNC);
+            cache.setRebalanceMode(SYNC);
             cache.setWriteSynchronizationMode(FULL_SYNC);
             cache.setAffinity(new CacheRendezvousAffinityFunction(false, 100));
 
@@ -1957,7 +1957,7 @@ public class IgnitionEx {
             ccfg.setAtomicityMode(TRANSACTIONAL);
             ccfg.setSwapEnabled(false);
             ccfg.setQueryIndexEnabled(false);
-            ccfg.setPreloadMode(SYNC);
+            ccfg.setRebalanceMode(SYNC);
             ccfg.setWriteSynchronizationMode(FULL_SYNC);
             ccfg.setCacheMode(cfg.getCacheMode());
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAttributes.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAttributes.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAttributes.java
index a4762ab..00679c0 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAttributes.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAttributes.java
@@ -70,14 +70,14 @@ public class GridCacheAttributes implements Externalizable {
     /** Flag indicating if cached values should be additionally stored in serialized form. */
     private boolean storeValBytes;
 
-    /** Cache preload mode. */
-    private CachePreloadMode preloadMode;
+    /** Cache rebalance mode. */
+    private CacheRebalanceMode rebalanceMode;
 
     /** Partitioned cache mode. */
     private CacheDistributionMode partDistro;
 
-    /** Preload batch size. */
-    private int preloadBatchSize;
+    /** Rebalance batch size. */
+    private int rebalanceBatchSize;
 
     /** Synchronization mode. */
     private CacheWriteSynchronizationMode writeSyncMode;
@@ -170,8 +170,8 @@ public class GridCacheAttributes implements Externalizable {
         loadPrevVal = cfg.isLoadPreviousValue();
         name = cfg.getName();
         partDistro = GridCacheUtils.distributionMode(cfg);
-        preloadBatchSize = cfg.getPreloadBatchSize();
-        preloadMode = cfg.getPreloadMode();
+        rebalanceBatchSize = cfg.getRebalanceBatchSize();
+        rebalanceMode = cfg.getRebalanceMode();
         qryIdxEnabled = cfg.isQueryIndexEnabled();
         readThrough = cfg.isReadThrough();
         storeValBytes = cfg.isStoreValueBytes();
@@ -261,10 +261,10 @@ public class GridCacheAttributes implements Externalizable {
     }
 
     /**
-     * @return Preload mode.
+     * @return Rebalance mode.
      */
-    public CachePreloadMode cachePreloadMode() {
-        return preloadMode;
+    public CacheRebalanceMode cacheRebalanceMode() {
+        return rebalanceMode;
     }
 
     /**
@@ -423,10 +423,10 @@ public class GridCacheAttributes implements Externalizable {
     }
 
     /**
-     * @return Preload batch size.
+     * @return Rebalance batch size.
      */
-    public int preloadBatchSize() {
-        return preloadBatchSize;
+    public int rebalanceBatchSize() {
+        return rebalanceBatchSize;
     }
 
     /**
@@ -519,8 +519,8 @@ public class GridCacheAttributes implements Externalizable {
         out.writeBoolean(loadPrevVal);
         U.writeString(out, name);
         U.writeEnum(out, partDistro);
-        out.writeInt(preloadBatchSize);
-        U.writeEnum(out, preloadMode);
+        out.writeInt(rebalanceBatchSize);
+        U.writeEnum(out, rebalanceMode);
         out.writeBoolean(qryIdxEnabled);
         out.writeBoolean(readThrough);
         out.writeBoolean(storeValBytes);
@@ -563,8 +563,8 @@ public class GridCacheAttributes implements Externalizable {
         loadPrevVal = in.readBoolean();
         name = U.readString(in);
         partDistro = CacheDistributionMode.fromOrdinal(in.readByte());
-        preloadBatchSize = in.readInt();
-        preloadMode = CachePreloadMode.fromOrdinal(in.readByte());
+        rebalanceBatchSize = in.readInt();
+        rebalanceMode = CacheRebalanceMode.fromOrdinal(in.readByte());
         qryIdxEnabled = in.readBoolean();
         readThrough = in.readBoolean();
         storeValBytes = in.readBoolean();

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheContext.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheContext.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheContext.java
index 3ec013c..22c7fe4 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheContext.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheContext.java
@@ -63,7 +63,7 @@ import java.util.concurrent.*;
 
 import static org.apache.ignite.cache.CacheAtomicityMode.*;
 import static org.apache.ignite.cache.CacheMemoryMode.*;
-import static org.apache.ignite.cache.CachePreloadMode.*;
+import static org.apache.ignite.cache.CacheRebalanceMode.*;
 import static org.apache.ignite.cache.CacheWriteSynchronizationMode.*;
 import static org.apache.ignite.internal.managers.communication.GridIoPolicy.*;
 import static org.apache.ignite.internal.processors.cache.CacheFlag.*;
@@ -635,10 +635,10 @@ public class GridCacheContext<K, V> implements Externalizable {
     }
 
     /**
-     * @return {@code True} if preload is enabled.
+     * @return {@code True} if rebalance is enabled.
      */
-    public boolean preloadEnabled() {
-        return cacheCfg.getPreloadMode() != NONE;
+    public boolean rebalanceEnabled() {
+        return cacheCfg.getRebalanceMode() != NONE;
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEventManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEventManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEventManager.java
index e1ff9c0..781005a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEventManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEventManager.java
@@ -219,8 +219,8 @@ public class GridCacheEventManager<K, V> extends GridCacheManagerAdapter<K, V> {
         if (!cctx.events().isRecordable(type))
             LT.warn(log, null, "Added event without checking if event is recordable: " + U.gridEventName(type));
 
-        cctx.gridEvents().record(new CachePreloadingEvent(cctx.name(), cctx.localNode(),
-            "Cache preloading event.", type, part, discoNode, discoType, discoTs));
+        cctx.gridEvents().record(new CacheRebalancingEvent(cctx.name(), cctx.localNode(),
+            "Cache rebalancing event.", type, part, discoNode, discoType, discoTs));
     }
 
     /**
@@ -229,12 +229,12 @@ public class GridCacheEventManager<K, V> extends GridCacheManagerAdapter<K, V> {
      * @param part Partition.
      */
     public void addUnloadEvent(int part) {
-        if (!cctx.events().isRecordable(EVT_CACHE_PRELOAD_PART_UNLOADED))
+        if (!cctx.events().isRecordable(EVT_CACHE_REBALANCE_PART_UNLOADED))
             LT.warn(log, null, "Added event without checking if event is recordable: " +
-                U.gridEventName(EVT_CACHE_PRELOAD_PART_UNLOADED));
+                U.gridEventName(EVT_CACHE_REBALANCE_PART_UNLOADED));
 
-        cctx.gridEvents().record(new CachePreloadingEvent(cctx.name(), cctx.localNode(),
-            "Cache unloading event.", EVT_CACHE_PRELOAD_PART_UNLOADED, part, null, 0, 0));
+        cctx.gridEvents().record(new CacheRebalancingEvent(cctx.name(), cctx.localNode(),
+            "Cache unloading event.", EVT_CACHE_REBALANCE_PART_UNLOADED, part, null, 0, 0));
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEvictionManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEvictionManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEvictionManager.java
index 382eb61..a7f9310 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEvictionManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEvictionManager.java
@@ -494,7 +494,7 @@ public class GridCacheEvictionManager<K, V> extends GridCacheManagerAdapter<K, V
      * @param p Partition ID.
      */
     private void saveEvictionInfo(K key, GridCacheVersion ver, int p) {
-        assert cctx.preloadEnabled();
+        assert cctx.rebalanceEnabled();
 
         if (!cctx.isNear()) {
             try {
@@ -520,7 +520,7 @@ public class GridCacheEvictionManager<K, V> extends GridCacheManagerAdapter<K, V
      *      {@code false} if preloading is finished or disabled and no lock is needed.
      */
     private boolean lockPartition(int p) {
-        if (!cctx.preloadEnabled())
+        if (!cctx.rebalanceEnabled())
             return false;
 
         if (!cctx.isNear()) {
@@ -556,7 +556,7 @@ public class GridCacheEvictionManager<K, V> extends GridCacheManagerAdapter<K, V
      * @param p Partition ID.
      */
     private void unlockPartition(int p) {
-        if (!cctx.preloadEnabled())
+        if (!cctx.rebalanceEnabled())
             return;
 
         if (!cctx.isNear()) {

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java
index d7b1914..482b5a5 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java
@@ -824,11 +824,11 @@ public class GridCachePartitionExchangeManager<K, V> extends GridCacheSharedMana
                                 changed |= cacheCtx.topology().afterExchange(exchFut.exchangeId());
 
                                 // Preload event notification.
-                                if (cacheCtx.events().isRecordable(EVT_CACHE_PRELOAD_STARTED)) {
+                                if (cacheCtx.events().isRecordable(EVT_CACHE_REBALANCE_STARTED)) {
                                     if (!cacheCtx.isReplicated() || !startEvtFired) {
                                         DiscoveryEvent discoEvt = exchFut.discoveryEvent();
 
-                                        cacheCtx.events().addPreloadEvent(-1, EVT_CACHE_PRELOAD_STARTED,
+                                        cacheCtx.events().addPreloadEvent(-1, EVT_CACHE_REBALANCE_STARTED,
                                             discoEvt.eventNode(), discoEvt.type(), discoEvt.timestamp());
                                     }
                                 }
@@ -851,7 +851,7 @@ public class GridCachePartitionExchangeManager<K, V> extends GridCacheSharedMana
                         }
 
                         for (GridCacheContext<K, V> cacheCtx : cctx.cacheContexts()) {
-                            long delay = cacheCtx.config().getPreloadPartitionedDelay();
+                            long delay = cacheCtx.config().getRebalancePartitionedDelay();
 
                             GridDhtPreloaderAssignments<K, V> assigns = null;
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
index e99c706..c427053 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
@@ -60,7 +60,7 @@ import static org.apache.ignite.cache.CacheAtomicityMode.*;
 import static org.apache.ignite.configuration.CacheConfiguration.*;
 import static org.apache.ignite.cache.CacheDistributionMode.*;
 import static org.apache.ignite.cache.CacheMode.*;
-import static org.apache.ignite.cache.CachePreloadMode.*;
+import static org.apache.ignite.cache.CacheRebalanceMode.*;
 import static org.apache.ignite.cache.CacheWriteSynchronizationMode.*;
 import static org.apache.ignite.configuration.DeploymentMode.*;
 import static org.apache.ignite.internal.IgniteNodeAttributes.*;
@@ -90,8 +90,8 @@ public class GridCacheProcessor extends GridProcessorAdapter {
     /** Map of preload finish futures grouped by preload order. */
     private final NavigableMap<Integer, IgniteInternalFuture<?>> preloadFuts;
 
-    /** Maximum detected preload order. */
-    private int maxPreloadOrder;
+    /** Maximum detected rebalance order. */
+    private int maxRebalanceOrder;
 
     /** System cache names. */
     private final Set<String> sysCaches;
@@ -169,8 +169,8 @@ public class GridCacheProcessor extends GridProcessorAdapter {
 
         ctx.igfsHelper().preProcessCacheConfiguration(cfg);
 
-        if (cfg.getPreloadMode() == null)
-            cfg.setPreloadMode(ASYNC);
+        if (cfg.getRebalanceMode() == null)
+            cfg.setRebalanceMode(ASYNC);
 
         if (cfg.getAtomicityMode() == null)
             cfg.setAtomicityMode(ATOMIC);
@@ -333,9 +333,9 @@ public class GridCacheProcessor extends GridProcessorAdapter {
             U.warn(log, "CacheAffinityFunction configuration parameter will be ignored for local cache [cacheName=" +
                 cc.getName() + ']');
 
-        if (cc.getPreloadMode() != CachePreloadMode.NONE) {
-            assertParameter(cc.getPreloadThreadPoolSize() > 0, "preloadThreadPoolSize > 0");
-            assertParameter(cc.getPreloadBatchSize() > 0, "preloadBatchSize > 0");
+        if (cc.getRebalanceMode() != CacheRebalanceMode.NONE) {
+            assertParameter(cc.getRebalanceThreadPoolSize() > 0, "rebalanceThreadPoolSize > 0");
+            assertParameter(cc.getRebalanceBatchSize() > 0, "rebalanceBatchSize > 0");
         }
 
         if (cc.getCacheMode() == PARTITIONED || cc.getCacheMode() == REPLICATED) {
@@ -384,23 +384,23 @@ public class GridCacheProcessor extends GridProcessorAdapter {
             throw new IgniteCheckedException("Cannot enable write-through (writer or store is not provided) " +
                 "for cache: " + cc.getName());
 
-        long delay = cc.getPreloadPartitionedDelay();
+        long delay = cc.getRebalancePartitionedDelay();
 
         if (delay != 0) {
             if (cc.getCacheMode() != PARTITIONED)
-                U.warn(log, "Preload delay is supported only for partitioned caches (will ignore): " + cc.getName(),
-                    "Will ignore preload delay for cache: " + cc.getName());
-            else if (cc.getPreloadMode() == SYNC) {
+                U.warn(log, "Rebalance delay is supported only for partitioned caches (will ignore): " + cc.getName(),
+                    "Will ignore rebalance delay for cache: " + cc.getName());
+            else if (cc.getRebalanceMode() == SYNC) {
                 if (delay < 0) {
-                    U.warn(log, "Ignoring SYNC preload mode with manual preload start (node will not wait for " +
-                        "preloading to be finished): " + cc.getName(),
-                        "Node will not wait for preload in SYNC mode: " + cc.getName());
+                    U.warn(log, "Ignoring SYNC rebalance mode with manual rebalance start (node will not wait for " +
+                        "rebalancing to be finished): " + cc.getName(),
+                        "Node will not wait for rebalance in SYNC mode: " + cc.getName());
                 }
                 else {
                     U.warn(log,
-                        "Using SYNC preload mode with preload delay (node will wait until preloading is " +
+                        "Using SYNC rebalance mode with rebalance delay (node will wait until rebalancing is " +
                             "initiated for " + delay + "ms) for cache: " + cc.getName(),
-                        "Node will wait until preloading is initiated for " + delay + "ms for cache: " + cc.getName());
+                        "Node will wait until rebalancing is initiated for " + delay + "ms for cache: " + cc.getName());
                 }
             }
         }
@@ -556,7 +556,7 @@ public class GridCacheProcessor extends GridProcessorAdapter {
                     "Deployment mode for cache is not CONTINUOUS or SHARED.");
         }
 
-        maxPreloadOrder = validatePreloadOrder(ctx.config().getCacheConfiguration());
+        maxRebalanceOrder = validatePreloadOrder(ctx.config().getCacheConfiguration());
 
         // Internal caches which should not be returned to user.
         IgfsConfiguration[] igfsCfgs = ctx.grid().configuration().getIgfsConfiguration();
@@ -967,23 +967,23 @@ public class GridCacheProcessor extends GridProcessorAdapter {
         int maxOrder = 0;
 
         for (CacheConfiguration cfg : cfgs) {
-            int preloadOrder = cfg.getPreloadOrder();
+            int rebalanceOrder = cfg.getRebalanceOrder();
 
-            if (preloadOrder > 0) {
+            if (rebalanceOrder > 0) {
                 if (cfg.getCacheMode() == LOCAL)
-                    throw new IgniteCheckedException("Preload order set for local cache (fix configuration and restart the " +
+                    throw new IgniteCheckedException("Rebalance order set for local cache (fix configuration and restart the " +
                         "node): " + cfg.getName());
 
-                if (cfg.getPreloadMode() == CachePreloadMode.NONE)
-                    throw new IgniteCheckedException("Only caches with SYNC or ASYNC preload mode can be set as preload " +
+                if (cfg.getRebalanceMode() == CacheRebalanceMode.NONE)
+                    throw new IgniteCheckedException("Only caches with SYNC or ASYNC rebalance mode can be set as rebalance " +
                         "dependency for other caches [cacheName=" + cfg.getName() +
-                        ", preloadMode=" + cfg.getPreloadMode() + ", preloadOrder=" + cfg.getPreloadOrder() + ']');
+                        ", rebalanceMode=" + cfg.getRebalanceMode() + ", rebalanceOrder=" + cfg.getRebalanceOrder() + ']');
 
-                maxOrder = Math.max(maxOrder, preloadOrder);
+                maxOrder = Math.max(maxOrder, rebalanceOrder);
             }
-            else if (preloadOrder < 0)
-                throw new IgniteCheckedException("Preload order cannot be negative for cache (fix configuration and restart " +
-                    "the node) [cacheName=" + cfg.getName() + ", preloadOrder=" + preloadOrder + ']');
+            else if (rebalanceOrder < 0)
+                throw new IgniteCheckedException("Rebalance order cannot be negative for cache (fix configuration and restart " +
+                    "the node) [cacheName=" + cfg.getName() + ", rebalanceOrder=" + rebalanceOrder + ']');
         }
 
         return maxOrder;
@@ -1080,8 +1080,8 @@ public class GridCacheProcessor extends GridProcessorAdapter {
                         CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "atomicityMode",
                             "Cache atomicity mode", locAttr.atomicityMode(), rmtAttr.atomicityMode(), true);
 
-                        CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "cachePreloadMode",
-                            "Cache preload mode", locAttr.cachePreloadMode(), rmtAttr.cachePreloadMode(), true);
+                        CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "cacheRebalanceMode",
+                            "Cache rebalance mode", locAttr.cacheRebalanceMode(), rmtAttr.cacheRebalanceMode(), true);
 
                         CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "cacheAffinity", "Cache affinity",
                             locAttr.cacheAffinityClassName(), rmtAttr.cacheAffinityClassName(), true);
@@ -1129,8 +1129,8 @@ public class GridCacheProcessor extends GridProcessorAdapter {
                         CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "defaultTimeToLive",
                             "Default time to live", locAttr.defaultTimeToLive(), rmtAttr.defaultTimeToLive(), false);
 
-                        CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "preloadBatchSize",
-                            "Preload batch size", locAttr.preloadBatchSize(), rmtAttr.preloadBatchSize(), false);
+                        CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "rebalanceBatchSize",
+                            "Rebalance batch size", locAttr.rebalanceBatchSize(), rmtAttr.rebalanceBatchSize(), false);
 
                         CU.checkAttributeMismatch(log, rmtAttr.cacheName(), rmt, "swapEnabled",
                             "Swap enabled", locAttr.swapEnabled(), rmtAttr.swapEnabled(), false);
@@ -1298,12 +1298,12 @@ public class GridCacheProcessor extends GridProcessorAdapter {
         for (Map.Entry<String, GridCacheAdapter<?, ?>> e : caches.entrySet()) {
             GridCacheAdapter cache = e.getValue();
 
-            if (maxPreloadOrder > 0) {
+            if (maxRebalanceOrder > 0) {
                 CacheConfiguration cfg = cache.configuration();
 
-                int order = cfg.getPreloadOrder();
+                int order = cfg.getRebalanceOrder();
 
-                if (order > 0 && order != maxPreloadOrder && cfg.getCacheMode() != LOCAL) {
+                if (order > 0 && order != maxRebalanceOrder && cfg.getCacheMode() != LOCAL) {
                     GridCompoundFuture<Object, Object> fut = (GridCompoundFuture<Object, Object>)preloadFuts
                         .get(order);
 
@@ -1331,9 +1331,9 @@ public class GridCacheProcessor extends GridProcessorAdapter {
         for (GridCacheAdapter<?, ?> cache : caches.values()) {
             CacheConfiguration cfg = cache.configuration();
 
-            if (cfg.getPreloadMode() == SYNC) {
+            if (cfg.getRebalanceMode() == SYNC) {
                 if (cfg.getCacheMode() == REPLICATED ||
-                    (cfg.getCacheMode() == PARTITIONED && cfg.getPreloadPartitionedDelay() >= 0))
+                    (cfg.getCacheMode() == PARTITIONED && cfg.getRebalancePartitionedDelay() >= 0))
                     cache.preloader().syncFuture().get();
             }
         }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/dc04e98c/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheUtils.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheUtils.java
index 1e67907..004dda3 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheUtils.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheUtils.java
@@ -49,7 +49,7 @@ import static org.apache.ignite.IgniteSystemProperties.*;
 import static org.apache.ignite.cache.CacheAtomicityMode.*;
 import static org.apache.ignite.cache.CacheDistributionMode.*;
 import static org.apache.ignite.cache.CacheMode.*;
-import static org.apache.ignite.cache.CachePreloadMode.*;
+import static org.apache.ignite.cache.CacheRebalanceMode.*;
 import static org.apache.ignite.cache.CacheWriteSynchronizationMode.*;
 import static org.apache.ignite.internal.GridTopic.*;
 import static org.apache.ignite.internal.IgniteNodeAttributes.*;
@@ -1512,7 +1512,7 @@ public class GridCacheUtils {
         cache.setQueryIndexEnabled(false);
         cache.setCacheStoreFactory(null);
         cache.setEagerTtl(true);
-        cache.setPreloadMode(SYNC);
+        cache.setRebalanceMode(SYNC);
 
         return cache;
     }


Mime
View raw message