ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From agoncha...@apache.org
Subject [18/29] incubator-ignite git commit: IGNITE-575 - Renaimings
Date Wed, 25 Mar 2015 06:54:02 GMT
IGNITE-575 - Renaimings


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

Branch: refs/heads/ignite-341
Commit: 4ba0b01a4c5e2511039b38332a862eed65d1ed24
Parents: 740d4be
Author: Valentin Kulichenko <vkulichenko@gridgain.com>
Authored: Tue Mar 24 20:43:32 2015 -0700
Committer: Valentin Kulichenko <vkulichenko@gridgain.com>
Committed: Tue Mar 24 20:43:34 2015 -0700

----------------------------------------------------------------------
 .../examples/datagrid/CacheQueryExample.java    |  38 +-
 .../examples/ScalarCacheQueryExample.scala      |  12 +-
 .../ClientAbstractMultiThreadedSelfTest.java    |   2 +-
 .../ClientAbstractMultiNodeSelfTest.java        |   2 +-
 .../ignite/jdbc/JdbcComplexQuerySelfTest.java   |  13 +-
 .../ignite/jdbc/JdbcMetadataSelfTest.java       |  13 +-
 .../src/test/resources/spring-server-node.xml   |   2 +-
 .../test/resources/spring-server-ssl-node.xml   |   2 +-
 .../src/main/java/org/apache/ignite/Ignite.java |   2 +-
 .../java/org/apache/ignite/IgniteCache.java     |   2 +-
 .../java/org/apache/ignite/IgniteCluster.java   |   4 +-
 .../org/apache/ignite/IgniteJdbcDriver.java     |   3 +-
 .../apache/ignite/cache/CacheMemoryMode.java    |   6 +-
 .../java/org/apache/ignite/cache/CacheMode.java |   5 +-
 .../apache/ignite/cache/CacheRebalanceMode.java |   3 +-
 .../apache/ignite/cache/affinity/Affinity.java  | 246 ++++++
 .../ignite/cache/affinity/AffinityFunction.java | 110 +++
 .../cache/affinity/AffinityFunctionContext.java |  72 ++
 .../ignite/cache/affinity/AffinityKey.java      | 189 +++++
 .../cache/affinity/AffinityKeyMapped.java       | 110 +++
 .../cache/affinity/AffinityKeyMapper.java       |  62 ++
 .../AffinityNodeAddressHashResolver.java        |  39 +
 .../affinity/AffinityNodeHashResolver.java      |  43 +
 .../affinity/AffinityNodeIdHashResolver.java    |  40 +
 .../ignite/cache/affinity/CacheAffinity.java    | 246 ------
 .../cache/affinity/CacheAffinityFunction.java   | 110 ---
 .../affinity/CacheAffinityFunctionContext.java  |  72 --
 .../ignite/cache/affinity/CacheAffinityKey.java | 189 -----
 .../cache/affinity/CacheAffinityKeyMapped.java  | 110 ---
 .../cache/affinity/CacheAffinityKeyMapper.java  |  62 --
 .../CacheAffinityNodeAddressHashResolver.java   |  39 -
 .../affinity/CacheAffinityNodeHashResolver.java |  43 -
 .../CacheAffinityNodeIdHashResolver.java        |  40 -
 .../CacheCentralizedAffinityFunction.java       |  31 -
 .../affinity/CentralizedAffinityFunction.java   |  31 +
 .../fair/CachePartitionFairAffinity.java        | 777 -------------------
 .../affinity/fair/FairAffinityFunction.java     | 777 +++++++++++++++++++
 .../CacheRendezvousAffinityFunction.java        | 501 ------------
 .../rendezvous/RendezvousAffinityFunction.java  | 500 ++++++++++++
 .../cache/eviction/CacheEvictableEntry.java     |  96 ---
 .../cache/eviction/CacheEvictionFilter.java     |  43 -
 .../cache/eviction/CacheEvictionPolicy.java     |  50 --
 .../ignite/cache/eviction/EvictableEntry.java   |  96 +++
 .../ignite/cache/eviction/EvictionFilter.java   |  43 +
 .../ignite/cache/eviction/EvictionPolicy.java   |  54 ++
 .../eviction/fifo/CacheFifoEvictionPolicy.java  | 192 -----
 .../fifo/CacheFifoEvictionPolicyMBean.java      |  50 --
 .../cache/eviction/fifo/FifoEvictionPolicy.java | 191 +++++
 .../eviction/fifo/FifoEvictionPolicyMBean.java  |  50 ++
 .../eviction/igfs/CacheIgfsEvictionFilter.java  |  38 -
 .../CacheIgfsPerBlockLruEvictionPolicy.java     | 378 ---------
 ...acheIgfsPerBlockLruEvictionPolicyMXBean.java |  93 ---
 .../cache/eviction/igfs/IgfsEvictionFilter.java |  38 +
 .../igfs/IgfsPerBlockLruEvictionPolicy.java     | 376 +++++++++
 .../IgfsPerBlockLruEvictionPolicyMXBean.java    |  93 +++
 .../eviction/lru/CacheLruEvictionPolicy.java    | 199 -----
 .../lru/CacheLruEvictionPolicyMBean.java        |  50 --
 .../cache/eviction/lru/LruEvictionPolicy.java   | 198 +++++
 .../eviction/lru/LruEvictionPolicyMBean.java    |  50 ++
 .../random/CacheRandomEvictionPolicy.java       | 115 ---
 .../random/CacheRandomEvictionPolicyMBean.java  |  42 -
 .../eviction/random/RandomEvictionPolicy.java   | 114 +++
 .../random/RandomEvictionPolicyMBean.java       |  42 +
 .../configuration/CacheConfiguration.java       |  36 +-
 .../configuration/NearCacheConfiguration.java   |   6 +-
 .../apache/ignite/internal/IgniteKernal.java    |   2 +-
 .../org/apache/ignite/internal/IgnitionEx.java  |   4 +-
 .../affinity/GridAffinityAssignmentCache.java   |  14 +-
 .../GridAffinityFunctionContextImpl.java        |  83 ++
 .../affinity/GridAffinityProcessor.java         |  22 +-
 .../processors/affinity/GridAffinityUtils.java  |   7 +-
 .../GridCacheAffinityFunctionContextImpl.java   |  83 --
 .../cache/CacheEvictableEntryImpl.java          |   2 +-
 .../processors/cache/CacheObjectContext.java    |   6 +-
 .../processors/cache/CacheProjection.java       |   6 +-
 .../internal/processors/cache/GridCache.java    |   7 +-
 .../processors/cache/GridCacheAdapter.java      |   4 +-
 .../processors/cache/GridCacheAttributes.java   |  12 +-
 .../processors/cache/GridCacheContext.java      |  12 +-
 .../GridCacheDefaultAffinityKeyMapper.java      |  14 +-
 .../processors/cache/GridCacheEntryEx.java      |   2 +-
 .../cache/GridCacheEvictionManager.java         |   4 +-
 .../processors/cache/GridCacheMapEntry.java     |   4 +-
 .../cache/GridCachePreloaderAdapter.java        |   2 +-
 .../processors/cache/GridCacheProcessor.java    |  36 +-
 .../processors/cache/GridCacheProxyImpl.java    |   4 +-
 .../processors/cache/GridCacheUtils.java        |   4 +-
 .../cache/affinity/GridCacheAffinityImpl.java   |   2 +-
 .../cache/affinity/GridCacheAffinityProxy.java  |   6 +-
 .../GridDhtPartitionsExchangeFuture.java        |   4 +-
 .../processors/cache/query/CacheQuery.java      |   3 +-
 .../GridCacheInternalKeyImpl.java               |   2 +-
 .../datastructures/GridCacheQueueAdapter.java   |   2 +-
 .../datastructures/GridCacheSetImpl.java        |   2 +-
 .../processors/igfs/IgfsDataManager.java        |   2 +-
 .../processors/igfs/IgfsHelperImpl.java         |  16 +-
 .../internal/processors/igfs/IgfsImpl.java      |   8 +-
 .../internal/processors/igfs/IgfsProcessor.java |   4 +-
 .../cache/VisorCacheAffinityConfiguration.java  |   6 +-
 .../cache/VisorCacheEvictionConfiguration.java  |   2 +-
 .../visor/cache/VisorCacheSwapBackupsTask.java  |   2 +-
 .../internal/visor/util/VisorTaskUtils.java     |  14 +-
 .../resources/META-INF/classnames.properties    |  32 +-
 .../core/src/test/config/discovery-stress.xml   |   2 +-
 .../config/load/dsi-49-server-production.xml    |   4 +-
 .../src/test/config/load/dsi-load-server.xml    |   2 +-
 .../core/src/test/config/spring-cache-swap.xml  |   2 +-
 .../src/test/config/spring-cache-teststore.xml  |   2 +-
 .../core/src/test/config/spring-multicache.xml  |  16 +-
 .../GridCacheAffinityBackupsSelfTest.java       |   8 +-
 .../ignite/IgniteCacheAffinitySelfTest.java     |  20 +-
 ...CachePartitionFairAffinityNodesSelfTest.java | 242 ------
 .../GridCachePartitionFairAffinitySelfTest.java | 264 -------
 .../GridFairAffinityFunctionNodesSelfTest.java  | 242 ++++++
 .../fair/GridFairAffinityFunctionSelfTest.java  | 264 +++++++
 .../ignite/internal/GridAffinityMappedTest.java |   4 +-
 .../internal/GridAffinityP2PSelfTest.java       |   4 +-
 .../GridJobMasterLeaveAwareSelfTest.java        |   6 +-
 .../internal/GridMultipleJobsSelfTest.java      |   2 +-
 .../GridAffinityProcessorAbstractSelfTest.java  |   2 +-
 ...GridAffinityProcessorRendezvousSelfTest.java |   4 +-
 ...cheNearUpdateTopologyChangeAbstractTest.java |   2 +-
 .../cache/GridCacheAbstractFullApiSelfTest.java |   6 +-
 ...acheAbstractUsersAffinityMapperSelfTest.java |   4 +-
 .../cache/GridCacheAffinityApiSelfTest.java     |  48 +-
 .../cache/GridCacheAffinityMapperSelfTest.java  |  14 +-
 .../cache/GridCacheAffinityRoutingSelfTest.java |   2 +-
 .../cache/GridCacheAlwaysEvictionPolicy.java    |   4 +-
 .../GridCacheAtomicMessageCountSelfTest.java    |   2 +-
 .../GridCacheConcurrentTxMultiNodeTest.java     |  28 +-
 ...idCacheConfigurationConsistencySelfTest.java |  56 +-
 ...ridCacheConfigurationValidationSelfTest.java |   6 +-
 .../GridCacheInterceptorAbstractSelfTest.java   |   6 +-
 .../processors/cache/GridCacheLeakTest.java     |   2 +-
 .../cache/GridCacheLifecycleAwareSelfTest.java  |  12 +-
 .../cache/GridCacheMemoryModeSelfTest.java      |   3 +-
 .../cache/GridCacheObjectToStringSelfTest.java  |  18 +-
 .../processors/cache/GridCacheOffHeapTest.java  |   2 +-
 .../GridCachePartitionedAffinitySpreadTest.java |   4 +-
 .../cache/GridCacheReloadSelfTest.java          |   2 +-
 .../processors/cache/GridCacheTestEntryEx.java  |   2 +-
 .../cache/IgniteCachePeekModesAbstractTest.java |  10 +-
 .../cache/IgniteCacheTxPreloadNoWriteTest.java  |   4 +-
 .../IgniteClientAffinityAssignmentSelfTest.java |   8 +-
 .../processors/cache/IgniteTxAbstractTest.java  |   4 +-
 .../cache/IgniteTxMultiNodeAbstractTest.java    |   2 +-
 ...GridCachePartitionedNodeRestartSelfTest.java |   2 +-
 ...dCachePartitionedQueueEntryMoveSelfTest.java |   8 +-
 .../GridCacheAtomicTimeoutSelfTest.java         |   2 +-
 .../GridCacheClientModesAbstractSelfTest.java   |   2 +-
 .../GridCacheModuloAffinityFunction.java        |   4 +-
 ...dCachePartitionedAffinityFilterSelfTest.java |   6 +-
 ...chePartitionedReloadAllAbstractSelfTest.java |   2 +-
 ...GridCachePreloadRestartAbstractSelfTest.java |   4 +-
 .../GridCacheTransformEventSelfTest.java        |   4 +-
 ...heAbstractTransformWriteThroughSelfTest.java |   2 +-
 .../dht/GridCacheAtomicNearCacheSelfTest.java   |  18 +-
 .../dht/GridCacheColocatedDebugTest.java        |   2 +-
 .../dht/GridCacheDhtEntrySelfTest.java          |   4 +-
 ...GridCacheDhtEvictionNearReadersSelfTest.java |   4 +-
 .../dht/GridCacheDhtEvictionSelfTest.java       |   4 +-
 .../dht/GridCacheDhtInternalEntrySelfTest.java  |   5 +-
 .../dht/GridCacheDhtPreloadBigDataSelfTest.java |   2 +-
 .../dht/GridCacheDhtPreloadDelayedSelfTest.java |   4 +-
 .../GridCacheDhtPreloadDisabledSelfTest.java    |   2 +-
 .../GridCacheDhtPreloadMessageCountTest.java    |   2 +-
 ...ridCacheDhtPreloadMultiThreadedSelfTest.java |   2 +-
 .../dht/GridCacheDhtPreloadSelfTest.java        |   8 +-
 .../GridCacheDhtPreloadStartStopSelfTest.java   |   6 +-
 .../dht/GridCacheDhtPreloadUnloadSelfTest.java  |   2 +-
 .../distributed/dht/GridCacheDhtTestUtils.java  |   9 +-
 ...idCachePartitionedPreloadEventsSelfTest.java |   6 +-
 ...dCachePartitionedTopologyChangeSelfTest.java |   6 +-
 ...ridCachePartitionedUnloadEventsSelfTest.java |   2 +-
 ...eAtomicInvalidPartitionHandlingSelfTest.java |   2 +-
 .../atomic/GridCacheAtomicPreloadSelfTest.java  |   2 +-
 ...unctionExcludeNeighborsAbstractSelfTest.java |   6 +-
 ...eAtomicNearOnlyMultiNodeFullApiSelfTest.java |   2 +-
 .../near/GridCacheNearMultiGetSelfTest.java     |   2 +-
 .../near/GridCacheNearMultiNodeSelfTest.java    |   6 +-
 .../near/GridCacheNearTxMultiNodeSelfTest.java  |   2 +-
 ...AffinityExcludeNeighborsPerformanceTest.java |  10 +-
 ...rtitionedAffinityHashIdResolverSelfTest.java |   6 +-
 .../GridCachePartitionedAffinitySelfTest.java   |   6 +-
 .../GridCachePartitionedEvictionSelfTest.java   |   6 +-
 .../GridCachePartitionedFullApiSelfTest.java    |   2 +-
 .../GridCachePartitionedLoadCacheSelfTest.java  |   2 +-
 ...achePartitionedMultiNodeCounterSelfTest.java |   6 +-
 ...achePartitionedMultiNodeFullApiSelfTest.java |   6 +-
 ...ePartitionedMultiThreadedPutGetSelfTest.java |   2 +-
 .../GridCachePartitionedNodeRestartTest.java    |   2 +-
 ...ePartitionedOptimisticTxNodeRestartTest.java |   2 +-
 .../GridCachePartitionedTxSalvageSelfTest.java  |   2 +-
 ...idCacheRendezvousAffinityClientSelfTest.java |   4 +-
 ...ffinityFunctionExcludeNeighborsSelfTest.java |   4 +-
 ...dezvousAffinityMultiNodeFullApiSelfTest.java |   4 +-
 .../GridCacheReplicatedPreloadSelfTest.java     |   4 +-
 .../GridCacheBatchEvictUnswapSelfTest.java      |   2 +-
 ...heConcurrentEvictionConsistencySelfTest.java |  26 +-
 .../GridCacheConcurrentEvictionsSelfTest.java   |   6 +-
 .../GridCacheDistributedEvictionsSelfTest.java  |   2 +-
 .../GridCacheEmptyEntriesAbstractSelfTest.java  |   8 +-
 .../eviction/GridCacheEvictionAbstractTest.java |  12 +-
 .../GridCacheEvictionFilterSelfTest.java        |  12 +-
 .../GridCacheEvictionLockUnlockSelfTest.java    |   4 +-
 .../GridCacheEvictionTouchSelfTest.java         |  24 +-
 .../cache/eviction/GridCacheMockEntry.java      |   3 +-
 ...cheSynchronousEvictionsFailoverSelfTest.java |   4 +-
 .../GridCacheFifoEvictionPolicySelfTest.java    |  20 +-
 .../lru/GridCacheLruEvictionPolicySelfTest.java |  22 +-
 .../GridCacheLruNearEvictionPolicySelfTest.java |   2 +-
 ...heNearOnlyLruNearEvictionPolicySelfTest.java |   2 +-
 .../GridCacheRandomEvictionPolicySelfTest.java  |  12 +-
 .../IgniteCacheLoadAllAbstractTest.java         |   2 +-
 .../DataStreamProcessorSelfTest.java            |   2 +-
 ...sCachePerBlockLruEvictionPolicySelfTest.java |   4 +-
 ...idOffHeapPartitionedMapAbstractSelfTest.java |   2 +-
 ...apPartitionedMapPerformanceAbstractTest.java |   2 +-
 ...GridUnsafePartitionedMapPerformanceTest.java |   2 +-
 .../loadtests/GridCacheMultiNodeLoadTest.java   |   2 +-
 .../capacity/spring-capacity-cache.xml          |   2 +-
 .../loadtests/colocation/GridTestKey.java       |   2 +-
 .../loadtests/colocation/spring-colocation.xml  |   2 +-
 .../GridCachePartitionedAtomicLongLoadTest.java |   4 +-
 .../ignite/loadtests/dsi/GridDsiPerfJob.java    |   2 +-
 .../ignite/loadtests/dsi/GridDsiRequest.java    |   2 +-
 .../ignite/loadtests/dsi/GridDsiResponse.java   |   4 +-
 .../ignite/loadtests/dsi/GridDsiSession.java    |   2 +-
 ...apPartitionedMapPerformanceAbstractTest.java |   2 +-
 ...GridUnsafePartitionedMapPerformanceTest.java |   2 +-
 .../swap/GridSwapEvictAllBenchmark.java         |   2 +-
 .../ignite/testframework/junits/IgniteMock.java |   2 +-
 .../junits/common/GridCommonAbstractTest.java   |  14 +-
 .../ignite/testsuites/IgniteCacheTestSuite.java |   2 +-
 .../tests/p2p/GridExternalAffinityFunction.java |   4 +-
 .../p2p/GridExternalAffinityKeyMapper.java      |   2 +-
 .../hibernate/HibernateL2CacheSelfTest.java     |   6 +-
 .../GridCacheAbstractFieldsQuerySelfTest.java   |  34 +-
 .../cache/GridIndexingWithNoopSwapSelfTest.java |   2 +-
 .../IgniteCacheAbstractFieldsQuerySelfTest.java |  26 +-
 .../IgniteCacheQueryMultiThreadedSelfTest.java  |   2 +-
 ...GridCachePartitionedFieldsQuerySelfTest.java |   6 +-
 ...dCacheAbstractReduceFieldsQuerySelfTest.java |  22 +-
 .../ignite/schema/generator/CodeGenerator.java  |   2 +-
 .../ignite/schema/ui/SchemaImportApp.java       |   4 +-
 .../org/apache/ignite/IgniteSpringBean.java     |   2 +-
 .../org/apache/ignite/yardstick/IgniteNode.java |   2 +-
 247 files changed, 4802 insertions(+), 4810 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/examples/src/main/java/org/apache/ignite/examples/datagrid/CacheQueryExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java/org/apache/ignite/examples/datagrid/CacheQueryExample.java b/examples/src/main/java/org/apache/ignite/examples/datagrid/CacheQueryExample.java
index 5c5168e..75c5b7e 100644
--- a/examples/src/main/java/org/apache/ignite/examples/datagrid/CacheQueryExample.java
+++ b/examples/src/main/java/org/apache/ignite/examples/datagrid/CacheQueryExample.java
@@ -40,7 +40,7 @@ import java.util.*;
  * <ul>
  *     <li>
  *         Joins will work correctly only if joined objects are stored in
- *         collocated mode. Refer to {@link CacheAffinityKey} javadoc for more details.
+ *         collocated mode. Refer to {@link AffinityKey} javadoc for more details.
  *     </li>
  *     <li>
  *         Note that if you created query on to replicated cache, all data will
@@ -75,7 +75,7 @@ public class CacheQueryExample {
             cfg.setName(CACHE_NAME);
             cfg.setIndexedTypes(
                 UUID.class, Organization.class,
-                CacheAffinityKey.class, Person.class
+                AffinityKey.class, Person.class
             );
 
             try (IgniteCache<?, ?> cache = ignite.createCache(cfg)) {
@@ -110,22 +110,22 @@ public class CacheQueryExample {
      * Example for SQL queries based on salary ranges.
      */
     private static void sqlQuery() {
-        IgniteCache<CacheAffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
+        IgniteCache<AffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
 
         // SQL clause which selects salaries based on range.
         String sql = "salary > ? and salary <= ?";
 
         // Execute queries for salary ranges.
         print("People with salaries between 0 and 1000: ",
-            cache.query(new SqlQuery<CacheAffinityKey<UUID>, Person>(Person.class, sql).
+            cache.query(new SqlQuery<AffinityKey<UUID>, Person>(Person.class, sql).
                 setArgs(0, 1000)).getAll());
 
         print("People with salaries between 1000 and 2000: ",
-            cache.query(new SqlQuery<CacheAffinityKey<UUID>, Person>(Person.class, sql).
+            cache.query(new SqlQuery<AffinityKey<UUID>, Person>(Person.class, sql).
                 setArgs(1000, 2000)).getAll());
 
         print("People with salaries greater than 2000: ",
-            cache.query(new SqlQuery<CacheAffinityKey<UUID>, Person>(Person.class, sql).
+            cache.query(new SqlQuery<AffinityKey<UUID>, Person>(Person.class, sql).
                 setArgs(2000, Integer.MAX_VALUE)).getAll());
     }
 
@@ -133,7 +133,7 @@ public class CacheQueryExample {
      * Example for SQL queries based on all employees working for a specific organization.
      */
     private static void sqlQueryWithJoin() {
-        IgniteCache<CacheAffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
+        IgniteCache<AffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
 
         // SQL clause query which joins on 2 types to select people for a specific organization.
         String joinSql =
@@ -143,10 +143,10 @@ public class CacheQueryExample {
 
         // Execute queries for find employees for different organizations.
         print("Following people are 'GridGain' employees: ",
-            cache.query(new SqlQuery<CacheAffinityKey<UUID>, Person>(Person.class, joinSql).
+            cache.query(new SqlQuery<AffinityKey<UUID>, Person>(Person.class, joinSql).
                 setArgs("GridGain")).getAll());
         print("Following people are 'Other' employees: ",
-            cache.query(new SqlQuery<CacheAffinityKey<UUID>, Person>(Person.class, joinSql).
+            cache.query(new SqlQuery<AffinityKey<UUID>, Person>(Person.class, joinSql).
                 setArgs("Other")).getAll());
     }
 
@@ -154,15 +154,15 @@ public class CacheQueryExample {
      * Example for TEXT queries using LUCENE-based indexing of people's resumes.
      */
     private static void textQuery() {
-        IgniteCache<CacheAffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
+        IgniteCache<AffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
 
         //  Query for all people with "Master Degree" in their resumes.
-        QueryCursor<Cache.Entry<CacheAffinityKey<UUID>, Person>> masters =
-            cache.query(new TextQuery<CacheAffinityKey<UUID>, Person>(Person.class, "Master"));
+        QueryCursor<Cache.Entry<AffinityKey<UUID>, Person>> masters =
+            cache.query(new TextQuery<AffinityKey<UUID>, Person>(Person.class, "Master"));
 
         // Query for all people with "Bachelor Degree" in their resumes.
-        QueryCursor<Cache.Entry<CacheAffinityKey<UUID>, Person>> bachelors =
-            cache.query(new TextQuery<CacheAffinityKey<UUID>, Person>(Person.class, "Bachelor"));
+        QueryCursor<Cache.Entry<AffinityKey<UUID>, Person>> bachelors =
+            cache.query(new TextQuery<AffinityKey<UUID>, Person>(Person.class, "Bachelor"));
 
         print("Following people have 'Master Degree' in their resumes: ", masters.getAll());
         print("Following people have 'Bachelor Degree' in their resumes: ", bachelors.getAll());
@@ -172,7 +172,7 @@ public class CacheQueryExample {
      * Example for SQL queries to calculate average salary for a specific organization.
      */
     private static void sqlQueryWithAggregation() {
-        IgniteCache<CacheAffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
+        IgniteCache<AffinityKey<UUID>, Person> cache = Ignition.ignite().cache(CACHE_NAME);
 
         // Calculate average of salary of all persons in GridGain.
         QueryCursor<List<?>> cursor = cache.query(new SqlFieldsQuery("select avg(salary) from Person, " +
@@ -192,7 +192,7 @@ public class CacheQueryExample {
 
         // Create query to get names of all employees.
         QueryCursor<List<?>> cursor = cache.query(new SqlFieldsQuery("select concat(firstName, ' ', " +
-            "lastName) from Person"));
+            "" + "lastName) from Person"));
 
         // Execute query to get collection of rows. In this particular
         // case each row will have one element with full name of an employees.
@@ -312,7 +312,7 @@ public class CacheQueryExample {
         private double salary;
 
         /** Custom cache key to guarantee that person is always collocated with its organization. */
-        private transient CacheAffinityKey<UUID> key;
+        private transient AffinityKey<UUID> key;
 
         /**
          * Constructs person record.
@@ -341,9 +341,9 @@ public class CacheQueryExample {
          *
          * @return Custom affinity key to guarantee that person is always collocated with organization.
          */
-        public CacheAffinityKey<UUID> key() {
+        public AffinityKey<UUID> key() {
             if (key == null)
-                key = new CacheAffinityKey<>(id, orgId);
+                key = new AffinityKey<>(id, orgId);
 
             return key;
         }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/examples/src/main/scala/org/apache/ignite/scalar/examples/ScalarCacheQueryExample.scala
----------------------------------------------------------------------
diff --git a/examples/src/main/scala/org/apache/ignite/scalar/examples/ScalarCacheQueryExample.scala b/examples/src/main/scala/org/apache/ignite/scalar/examples/ScalarCacheQueryExample.scala
index d471b35..50b68ca 100644
--- a/examples/src/main/scala/org/apache/ignite/scalar/examples/ScalarCacheQueryExample.scala
+++ b/examples/src/main/scala/org/apache/ignite/scalar/examples/ScalarCacheQueryExample.scala
@@ -20,7 +20,7 @@ package org.apache.ignite.scalar.examples
 import java.util._
 
 import org.apache.ignite.cache.CacheMode._
-import org.apache.ignite.cache.affinity.CacheAffinityKey
+import org.apache.ignite.cache.affinity.AffinityKey
 import org.apache.ignite.configuration.CacheConfiguration
 import org.apache.ignite.scalar.scalar
 import org.apache.ignite.scalar.scalar._
@@ -49,7 +49,7 @@ object ScalarCacheQueryExample {
     def main(args: Array[String]) {
         scalar(CONFIG) {
             val cache = createCache$(NAME, indexedTypes = Seq(classOf[UUID], classOf[Organization],
-                classOf[CacheAffinityKey[_]], classOf[Person]))
+                classOf[AffinityKey[_]], classOf[Person]))
 
             try {
                 example(ignite$)
@@ -70,12 +70,12 @@ object ScalarCacheQueryExample {
         initialize()
 
         // Cache instance shortcut.
-        val cache = mkCache[CacheAffinityKey[UUID], Person]
+        val cache = mkCache[AffinityKey[UUID], Person]
 
         // Using distributed queries for partitioned cache and local queries for replicated cache.
         // Since in replicated caches data is available on all nodes, including local one,
         // it is enough to just query the local node.
-        val prj = if (cache.getConfiguration(classOf[CacheConfiguration[CacheAffinityKey[UUID], Person]]).getCacheMode == PARTITIONED)
+        val prj = if (cache.getConfiguration(classOf[CacheConfiguration[AffinityKey[UUID], Person]]).getCacheMode == PARTITIONED)
             ignite.cluster().forRemotes()
         else
             ignite.cluster().forLocal()
@@ -114,7 +114,7 @@ object ScalarCacheQueryExample {
         orgCache += (org2.id -> org2)
 
         // Person cache projection.
-        val prnCache = mkCache[CacheAffinityKey[UUID], Person]
+        val prnCache = mkCache[AffinityKey[UUID], Person]
 
         // People.
         val p1 = Person(org1, "John", "Doe", 2000, "John Doe has Master Degree.")
@@ -181,7 +181,7 @@ private case class Person(
     val orgId = org.id
 
     /** Affinity key for this person. */
-    val key = new CacheAffinityKey[UUID](id, org.id)
+    val key = new AffinityKey[UUID](id, org.id)
 
     /**
      * `toString` implementation.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/clients/src/test/java/org/apache/ignite/internal/client/ClientAbstractMultiThreadedSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/clients/src/test/java/org/apache/ignite/internal/client/ClientAbstractMultiThreadedSelfTest.java b/modules/clients/src/test/java/org/apache/ignite/internal/client/ClientAbstractMultiThreadedSelfTest.java
index 41df0da..f1898df 100644
--- a/modules/clients/src/test/java/org/apache/ignite/internal/client/ClientAbstractMultiThreadedSelfTest.java
+++ b/modules/clients/src/test/java/org/apache/ignite/internal/client/ClientAbstractMultiThreadedSelfTest.java
@@ -180,7 +180,7 @@ public abstract class ClientAbstractMultiThreadedSelfTest extends GridCommonAbst
     private CacheConfiguration cacheConfiguration(@Nullable String cacheName) throws Exception {
         CacheConfiguration cfg = defaultCacheConfiguration();
 
-        cfg.setAffinity(new CacheRendezvousAffinityFunction());
+        cfg.setAffinity(new RendezvousAffinityFunction());
 
         cfg.setAtomicityMode(TRANSACTIONAL);
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/clients/src/test/java/org/apache/ignite/internal/client/integration/ClientAbstractMultiNodeSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/clients/src/test/java/org/apache/ignite/internal/client/integration/ClientAbstractMultiNodeSelfTest.java b/modules/clients/src/test/java/org/apache/ignite/internal/client/integration/ClientAbstractMultiNodeSelfTest.java
index 1d010e6..cf1b735 100644
--- a/modules/clients/src/test/java/org/apache/ignite/internal/client/integration/ClientAbstractMultiNodeSelfTest.java
+++ b/modules/clients/src/test/java/org/apache/ignite/internal/client/integration/ClientAbstractMultiNodeSelfTest.java
@@ -192,7 +192,7 @@ public abstract class ClientAbstractMultiNodeSelfTest extends GridCommonAbstract
 
         cfg.setWriteSynchronizationMode(REPLICATED_ASYNC_CACHE_NAME.equals(cacheName) ? FULL_ASYNC : FULL_SYNC);
 
-        cfg.setAffinity(new CacheRendezvousAffinityFunction());
+        cfg.setAffinity(new RendezvousAffinityFunction());
 
         return cfg;
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcComplexQuerySelfTest.java
----------------------------------------------------------------------
diff --git a/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcComplexQuerySelfTest.java b/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcComplexQuerySelfTest.java
index ade888e..a9bc246 100644
--- a/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcComplexQuerySelfTest.java
+++ b/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcComplexQuerySelfTest.java
@@ -57,10 +57,7 @@ public class JdbcComplexQuerySelfTest extends GridCommonAbstractTest {
         cache.setBackups(1);
         cache.setWriteSynchronizationMode(FULL_SYNC);
         cache.setAtomicityMode(TRANSACTIONAL);
-        cache.setIndexedTypes(
-            String.class, Organization.class,
-            CacheAffinityKey.class, Person.class
-        );
+        cache.setIndexedTypes(String.class, Organization.class, AffinityKey.class, Person.class);
 
         cfg.setCacheConfiguration(cache);
 
@@ -86,13 +83,13 @@ public class JdbcComplexQuerySelfTest extends GridCommonAbstractTest {
         orgCache.put("o1", new Organization(1, "A"));
         orgCache.put("o2", new Organization(2, "B"));
 
-        IgniteCache<CacheAffinityKey<String>, Person> personCache = grid(0).cache(null);
+        IgniteCache<AffinityKey<String>, Person> personCache = grid(0).cache(null);
 
         assert personCache != null;
 
-        personCache.put(new CacheAffinityKey<>("p1", "o1"), new Person(1, "John White", 25, 1));
-        personCache.put(new CacheAffinityKey<>("p2", "o1"), new Person(2, "Joe Black", 35, 1));
-        personCache.put(new CacheAffinityKey<>("p3", "o2"), new Person(3, "Mike Green", 40, 2));
+        personCache.put(new AffinityKey<>("p1", "o1"), new Person(1, "John White", 25, 1));
+        personCache.put(new AffinityKey<>("p2", "o1"), new Person(2, "Joe Black", 35, 1));
+        personCache.put(new AffinityKey<>("p3", "o2"), new Person(3, "Mike Green", 40, 2));
 
         Class.forName("org.apache.ignite.IgniteJdbcDriver");
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcMetadataSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcMetadataSelfTest.java b/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcMetadataSelfTest.java
index 39d2799..e1318d6 100644
--- a/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcMetadataSelfTest.java
+++ b/modules/clients/src/test/java/org/apache/ignite/jdbc/JdbcMetadataSelfTest.java
@@ -54,10 +54,7 @@ public class JdbcMetadataSelfTest extends GridCommonAbstractTest {
         cache.setCacheMode(PARTITIONED);
         cache.setBackups(1);
         cache.setWriteSynchronizationMode(FULL_SYNC);
-        cache.setIndexedTypes(
-            String.class, Organization.class,
-            CacheAffinityKey.class, Person.class
-        );
+        cache.setIndexedTypes(String.class, Organization.class, AffinityKey.class, Person.class);
 
         cfg.setCacheConfiguration(cache);
 
@@ -83,13 +80,13 @@ public class JdbcMetadataSelfTest extends GridCommonAbstractTest {
         orgCache.put("o1", new Organization(1, "A"));
         orgCache.put("o2", new Organization(2, "B"));
 
-        IgniteCache<CacheAffinityKey<String>, Person> personCache = grid(0).cache(null);
+        IgniteCache<AffinityKey<String>, Person> personCache = grid(0).cache(null);
 
         assert personCache != null;
 
-        personCache.put(new CacheAffinityKey<>("p1", "o1"), new Person("John White", 25, 1));
-        personCache.put(new CacheAffinityKey<>("p2", "o1"), new Person("Joe Black", 35, 1));
-        personCache.put(new CacheAffinityKey<>("p3", "o2"), new Person("Mike Green", 40, 2));
+        personCache.put(new AffinityKey<>("p1", "o1"), new Person("John White", 25, 1));
+        personCache.put(new AffinityKey<>("p2", "o1"), new Person("Joe Black", 35, 1));
+        personCache.put(new AffinityKey<>("p3", "o2"), new Person("Mike Green", 40, 2));
 
         Class.forName("org.apache.ignite.IgniteJdbcDriver");
     }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/clients/src/test/resources/spring-server-node.xml
----------------------------------------------------------------------
diff --git a/modules/clients/src/test/resources/spring-server-node.xml b/modules/clients/src/test/resources/spring-server-node.xml
index efc55e9..b6f18d0 100644
--- a/modules/clients/src/test/resources/spring-server-node.xml
+++ b/modules/clients/src/test/resources/spring-server-node.xml
@@ -118,7 +118,7 @@
                     <property name="writeSynchronizationMode" value="FULL_SYNC"/>
 
                     <property name="affinity">
-                        <bean class="org.apache.ignite.cache.affinity.rendezvous.CacheRendezvousAffinityFunction">
+                        <bean class="org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction">
                             <constructor-arg value="1"/>
                         </bean>
                     </property>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/clients/src/test/resources/spring-server-ssl-node.xml
----------------------------------------------------------------------
diff --git a/modules/clients/src/test/resources/spring-server-ssl-node.xml b/modules/clients/src/test/resources/spring-server-ssl-node.xml
index a7bac02..61b4a4b 100644
--- a/modules/clients/src/test/resources/spring-server-ssl-node.xml
+++ b/modules/clients/src/test/resources/spring-server-ssl-node.xml
@@ -120,7 +120,7 @@
                     <property name="writeSynchronizationMode" value="FULL_SYNC"/>
 
                     <property name="affinity">
-                        <bean class="org.apache.ignite.cache.affinity.rendezvous.CacheRendezvousAffinityFunction">
+                        <bean class="org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction">
                             <constructor-arg value="1"/>
                         </bean>
                     </property>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/Ignite.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/Ignite.java b/modules/core/src/main/java/org/apache/ignite/Ignite.java
index 5d4061d..36b6011 100644
--- a/modules/core/src/main/java/org/apache/ignite/Ignite.java
+++ b/modules/core/src/main/java/org/apache/ignite/Ignite.java
@@ -426,5 +426,5 @@ public interface Ignite extends AutoCloseable {
      * @param <K> Cache key type.
      * @return Affinity.
      */
-    public <K> CacheAffinity<K> affinity(String cacheName);
+    public <K> Affinity<K> affinity(String cacheName);
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteCache.java b/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
index f5ce8a6..b176f38 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteCache.java
@@ -507,7 +507,7 @@ public interface IgniteCache<K, V> extends javax.cache.Cache<K, V>, IgniteAsyncS
      * the left nodes, and that nodes are restarted before
      * {@link CacheConfiguration#getRebalanceDelay() rebalanceDelay} expires. To place nodes
      * on the same place in consistent hash ring, use
-     * {@link CacheRendezvousAffinityFunction#setHashIdResolver(CacheAffinityNodeHashResolver)} to make sure that
+     * {@link RendezvousAffinityFunction#setHashIdResolver(AffinityNodeHashResolver)} to make sure that
      * a node maps to the same hash ID if re-started.
      * <p>
      * See {@link CacheConfiguration#getRebalanceDelay()} for more information on how to configure

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java b/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
index c24ba5e..47930b1 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
@@ -110,7 +110,7 @@ public interface IgniteCluster extends ClusterGroup, IgniteAsyncSupport {
      * <ul>
      * <li>For local caches it returns only local node mapped to all keys.</li>
      * <li>
-     *      For fully replicated caches, {@link CacheAffinityFunction} is
+     *      For fully replicated caches, {@link AffinityFunction} is
      *      used to determine which keys are mapped to which groups of nodes.
      * </li>
      * <li>For partitioned caches, the returned map represents node-to-key affinity.</li>
@@ -133,7 +133,7 @@ public interface IgniteCluster extends ClusterGroup, IgniteAsyncSupport {
      * <ul>
      * <li>For local caches it returns only local node ID.</li>
      * <li>
-     *      For fully replicated caches first node ID returned by {@link CacheAffinityFunction}
+     *      For fully replicated caches first node ID returned by {@link AffinityFunction}
      *      is returned.
      * </li>
      * <li>For partitioned caches, the returned node ID is the primary node for the key.</li>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/IgniteJdbcDriver.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteJdbcDriver.java b/modules/core/src/main/java/org/apache/ignite/IgniteJdbcDriver.java
index d061c8f..a7c2eae 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteJdbcDriver.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteJdbcDriver.java
@@ -18,6 +18,7 @@
 package org.apache.ignite;
 
 
+import org.apache.ignite.cache.affinity.*;
 import org.apache.ignite.internal.jdbc.*;
 
 import java.sql.*;
@@ -40,7 +41,7 @@ import java.util.logging.*;
  *     <li>
  *         Joins will work correctly only if joined objects are stored in
  *         collocated mode. Refer to
- *         {@link org.apache.ignite.cache.affinity.CacheAffinityKey}
+ *         {@link AffinityKey}
  *         javadoc for more details.
  *     </li>
  *     <li>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/CacheMemoryMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheMemoryMode.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheMemoryMode.java
index 914a2e2..7a67fa5 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheMemoryMode.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheMemoryMode.java
@@ -17,6 +17,8 @@
 
 package org.apache.ignite.cache;
 
+import org.apache.ignite.cache.eviction.*;
+
 /**
  * Defines set of memory modes. Memory modes help control whether cache entries are
  * stored on heap memory, offheap memory, or in swap space.
@@ -37,7 +39,7 @@ public enum CacheMemoryMode {
      * </li>
      * </nl>
      * <p>
-     * <b>Note</b> that heap memory evictions are handled by configured {@link org.apache.ignite.cache.eviction.CacheEvictionPolicy}
+     * <b>Note</b> that heap memory evictions are handled by configured {@link EvictionPolicy}
      * implementation. By default, no eviction policy is enabled, so entries never leave heap
      * memory space unless explicitly removed.
      */
@@ -53,7 +55,7 @@ public enum CacheMemoryMode {
     /**
      * Entry keys will be stored on heap memory, and values will be stored in offheap memory. Note
      * that in this mode entries can be evicted only to swap. The evictions will happen according
-     * to configured {@link org.apache.ignite.cache.eviction.CacheEvictionPolicy}.
+     * to configured {@link EvictionPolicy}.
      */
     OFFHEAP_VALUES,
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/CacheMode.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheMode.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheMode.java
index fab1c82..56d31fb 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheMode.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheMode.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.cache;
 
+import org.apache.ignite.cache.affinity.*;
 import org.apache.ignite.configuration.*;
 import org.jetbrains.annotations.*;
 
@@ -40,7 +41,7 @@ public enum CacheMode {
     /**
      * Specifies fully replicated cache behavior. In this mode all the keys are distributed
      * to all participating nodes. User still has affinity control
-     * over subset of nodes for any given key via {@link org.apache.ignite.cache.affinity.CacheAffinityFunction}
+     * over subset of nodes for any given key via {@link AffinityFunction}
      * configuration.
      */
     REPLICATED,
@@ -49,7 +50,7 @@ public enum CacheMode {
      * Specifies partitioned cache behaviour. In this mode the overall
      * key set will be divided into partitions and all partitions will be split
      * equally between participating nodes. User has affinity
-     * control over key assignment via {@link org.apache.ignite.cache.affinity.CacheAffinityFunction}
+     * control over key assignment via {@link AffinityFunction}
      * configuration.
      * <p>
      * Note that partitioned cache is always fronted by local

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/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
index 90d9ba4..79d22f9 100644
--- a/modules/core/src/main/java/org/apache/ignite/cache/CacheRebalanceMode.java
+++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheRebalanceMode.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.cache;
 
+import org.apache.ignite.cache.affinity.*;
 import org.jetbrains.annotations.*;
 
 /**
@@ -26,7 +27,7 @@ import org.jetbrains.annotations.*;
  * 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
+ * pluggable {@link AffinityFunction}), 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}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/Affinity.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/Affinity.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/Affinity.java
new file mode 100644
index 0000000..835e142
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/Affinity.java
@@ -0,0 +1,246 @@
+/*
+ * 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.affinity;
+
+import org.apache.ignite.cluster.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ * Provides affinity information to detect which node is primary and which nodes are
+ * backups for a partitioned cache. You can get an instance of this interface by calling
+ * {@code Cache.affinity()} method.
+ * <p>
+ * Mapping of a key to a node is a three-step operation. First step will get an affinity key for given key
+ * using {@link AffinityKeyMapper}. If mapper is not specified, the original key will be used. Second step
+ * will map affinity key to partition using {@link AffinityFunction#partition(Object)} method. Third step
+ * will map obtained partition to nodes for current grid topology version.
+ * <p>
+ * Interface provides various {@code 'mapKeysToNodes(..)'} methods which provide node affinity mapping for
+ * given keys. All {@code 'mapKeysToNodes(..)'} methods are not transactional and will not enlist
+ * keys into ongoing transaction.
+ */
+public interface Affinity<K> {
+    /**
+     * Gets number of partitions in cache according to configured affinity function.
+     *
+     * @return Number of cache partitions.
+     * @see AffinityFunction
+     * @see org.apache.ignite.configuration.CacheConfiguration#getAffinity()
+     * @see org.apache.ignite.configuration.CacheConfiguration#setAffinity(AffinityFunction)
+     */
+    public int partitions();
+
+    /**
+     * Gets partition id for the given key.
+     *
+     * @param key Key to get partition id for.
+     * @return Partition id.
+     * @see AffinityFunction
+     * @see org.apache.ignite.configuration.CacheConfiguration#getAffinity()
+     * @see org.apache.ignite.configuration.CacheConfiguration#setAffinity(AffinityFunction)
+     */
+    public int partition(K key);
+
+    /**
+     * Returns {@code true} if given node is the primary node for given key.
+     *
+     * @param n Node to check.
+     * @param key Key to check.
+     * @return {@code True} if local node is the primary node for given key.
+     */
+    public boolean isPrimary(ClusterNode n, K key);
+
+    /**
+     * Returns {@code true} if local node is one of the backup nodes for given key.
+     *
+     * @param n Node to check.
+     * @param key Key to check.
+     * @return {@code True} if local node is one of the backup nodes for given key.
+     */
+    public boolean isBackup(ClusterNode n, K key);
+
+    /**
+     * Returns {@code true} if local node is primary or one of the backup nodes
+     * <p>
+     * This method is essentially equivalent to calling
+     * <i>"{@link #isPrimary(org.apache.ignite.cluster.ClusterNode, Object)} ||
+     *      {@link #isBackup(org.apache.ignite.cluster.ClusterNode, Object)})"</i>,
+     * however it is more efficient as it makes both checks at once.
+     *
+     * @param n Node to check.
+     * @param key Key to check.
+     * @return {@code True} if local node is primary or backup for given key.
+     */
+    public boolean isPrimaryOrBackup(ClusterNode n, K key);
+
+    /**
+     * Gets partition ids for which nodes of the given projection has primary
+     * ownership.
+     * <p>
+     * Note that since {@link org.apache.ignite.cluster.ClusterNode} implements {@link org.apache.ignite.cluster.ClusterGroup},
+     * to find out primary partitions for a single node just pass
+     * a single node into this method.
+     * <p>
+     * This method may return an empty array if none of nodes in the projection
+     * have nearOnly disabled.
+     *
+     * @param n Grid node.
+     * @return Partition ids for which given projection has primary ownership.
+     * @see AffinityFunction
+     * @see org.apache.ignite.configuration.CacheConfiguration#getAffinity()
+     * @see org.apache.ignite.configuration.CacheConfiguration#setAffinity(AffinityFunction)
+     */
+    public int[] primaryPartitions(ClusterNode n);
+
+    /**
+     * Gets partition ids for which nodes of the given projection has backup
+     * ownership. Note that you can find a back up at a certain level, e.g.
+     * {@code first} backup or {@code third} backup by specifying the
+     * {@code 'levels} parameter. If no {@code 'level'} is specified then
+     * all backup partitions are returned.
+     * <p>
+     * Note that since {@link org.apache.ignite.cluster.ClusterNode} implements {@link org.apache.ignite.cluster.ClusterGroup},
+     * to find out backup partitions for a single node, just pass that single
+     * node into this method.
+     * <p>
+     * This method may return an empty array if none of nodes in the projection
+     * have nearOnly disabled.
+     *
+     * @param n Grid node.
+     * @return Partition ids for which given projection has backup ownership.
+     * @see AffinityFunction
+     * @see org.apache.ignite.configuration.CacheConfiguration#getAffinity()
+     * @see org.apache.ignite.configuration.CacheConfiguration#setAffinity(AffinityFunction)
+     */
+    public int[] backupPartitions(ClusterNode n);
+
+    /**
+     * Gets partition ids for which nodes of the given projection has ownership
+     * (either primary or backup).
+     * <p>
+     * Note that since {@link org.apache.ignite.cluster.ClusterNode} implements {@link org.apache.ignite.cluster.ClusterGroup},
+     * to find out all partitions for a single node, just pass that single
+     * node into this method.
+     * <p>
+     * This method may return an empty array if none of nodes in the projection
+     * have nearOnly disabled.
+     *
+     * @param n Grid node.
+     * @return Partition ids for which given projection has ownership.
+     * @see AffinityFunction
+     * @see org.apache.ignite.configuration.CacheConfiguration#getAffinity()
+     * @see org.apache.ignite.configuration.CacheConfiguration#setAffinity(AffinityFunction)
+     */
+    public int[] allPartitions(ClusterNode n);
+
+    /**
+     * Maps passed in key to a key which will be used for node affinity. The affinity
+     * key may be different from actual key if some field in the actual key was
+     * designated for affinity mapping via {@link AffinityKeyMapped} annotation
+     * or if a custom {@link AffinityKeyMapper} was configured.
+     *
+     * @param key Key to map.
+     * @return Key to be used for node-to-affinity mapping (may be the same
+     *      key as passed in).
+     */
+    public Object affinityKey(K key);
+
+    /**
+     * This method provides ability to detect which keys are mapped to which nodes.
+     * Use it to determine which nodes are storing which keys prior to sending
+     * jobs that access these keys.
+     * <p>
+     * This method works as following:
+     * <ul>
+     * <li>For local caches it returns only local node mapped to all keys.</li>
+     * <li>
+     *      For fully replicated caches {@link AffinityFunction} is
+     *      used to determine which keys are mapped to which nodes.
+     * </li>
+     * <li>For partitioned caches, the returned map represents node-to-key affinity.</li>
+     * </ul>
+     *
+     * @param keys Keys to map to nodes.
+     * @return Map of nodes to keys or empty map if there are no alive nodes for this cache.
+     */
+    public Map<ClusterNode, Collection<K>> mapKeysToNodes(@Nullable Collection<? extends K> keys);
+
+    /**
+     * This method provides ability to detect to which primary node the given key
+     * is mapped. Use it to determine which nodes are storing which keys prior to sending
+     * jobs that access these keys.
+     * <p>
+     * This method works as following:
+     * <ul>
+     * <li>For local caches it returns only local node ID.</li>
+     * <li>
+     *      For fully replicated caches first node ID returned by {@link AffinityFunction}
+     *      is returned.
+     * </li>
+     * <li>For partitioned caches, primary node for the given key is returned.</li>
+     * </ul>
+     *
+     * @param key Keys to map to a node.
+     * @return Primary node for the key or {@code null} if there are no alive nodes for this cache.
+     */
+    @Nullable public ClusterNode mapKeyToNode(K key);
+
+    /**
+     * Gets primary and backup nodes for the key. Note that primary node is always
+     * first in the returned collection.
+     *
+     * @param key Key to get affinity nodes for.
+     * @return Collection of primary and backup nodes for the key with primary node
+     *      always first.
+     */
+    public Collection<ClusterNode> mapKeyToPrimaryAndBackups(K key);
+
+    /**
+     * Gets primary node for the given partition.
+     *
+     * @param part Partition id.
+     * @return Primary node for the given partition.
+     * @see AffinityFunction
+     * @see org.apache.ignite.configuration.CacheConfiguration#getAffinity()
+     * @see org.apache.ignite.configuration.CacheConfiguration#setAffinity(AffinityFunction)
+     */
+    public ClusterNode mapPartitionToNode(int part);
+
+    /**
+     * Gets primary nodes for the given partitions.
+     *
+     * @param parts Partition ids.
+     * @return Mapping of given partitions to their primary nodes.
+     * @see AffinityFunction
+     * @see org.apache.ignite.configuration.CacheConfiguration#getAffinity()
+     * @see org.apache.ignite.configuration.CacheConfiguration#setAffinity(AffinityFunction)
+     */
+    public Map<Integer, ClusterNode> mapPartitionsToNodes(Collection<Integer> parts);
+
+    /**
+     * Gets primary and backup nodes for partition. Note that primary node is always
+     * first in the returned collection.
+     *
+     * @param part Partition to get affinity nodes for.
+     * @return Collection of primary and backup nodes for partition with primary node
+     *      always first.
+     */
+    public Collection<ClusterNode> mapPartitionToPrimaryAndBackups(int part);
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunction.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunction.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunction.java
new file mode 100644
index 0000000..3278502
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunction.java
@@ -0,0 +1,110 @@
+/*
+ * 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.affinity;
+
+import org.apache.ignite.cluster.*;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Cache key affinity which maps keys to nodes. This interface is utilized for
+ * both, replicated and partitioned caches. Cache affinity can be configured
+ * for individual caches via {@link org.apache.ignite.configuration.CacheConfiguration#getAffinity()} method.
+ * <p>
+ * Whenever a key is given to cache, it is first passed to a pluggable
+ * {@link AffinityKeyMapper} which may potentially map this key to an alternate
+ * key which should be used for affinity. The key returned from
+ * {@link AffinityKeyMapper#affinityKey(Object)} method is then passed to
+ * {@link #partition(Object) partition(Object)} method to find out the partition for the key.
+ * On each topology change, partition-to-node mapping is calculated using
+ * {@link #assignPartitions(AffinityFunctionContext)} method, which assigns a collection
+ * of nodes to each partition.
+ * This collection of nodes is used for node affinity. In {@link org.apache.ignite.cache.CacheMode#REPLICATED REPLICATED}
+ * cache mode the key will be cached on all returned nodes; generally, all caching nodes
+ * participate in caching every key in replicated mode. In {@link org.apache.ignite.cache.CacheMode#PARTITIONED PARTITIONED}
+ * mode, only primary and backup nodes are returned with primary node always in the
+ * first position. So if there is {@code 1} backup node, then the returned collection will
+ * have {@code 2} nodes in it - {@code primary} node in first position, and {@code backup}
+ * node in second.
+ * <p>
+ * For more information about cache affinity and examples refer to {@link AffinityKeyMapper} and
+ * {@link AffinityKeyMapped @AffinityKeyMapped} documentation.
+ * @see AffinityKeyMapped
+ * @see AffinityKeyMapper
+ */
+public interface AffinityFunction extends Serializable {
+    /**
+     * Resets cache affinity to its initial state. This method will be called by
+     * the system any time the affinity has been sent to remote node where
+     * it has to be reinitialized. If your implementation of affinity function
+     * has no initialization logic, leave this method empty.
+     */
+    public void reset();
+
+    /**
+     * Gets total number of partitions available. All caches should always provide
+     * correct partition count which should be the same on all participating nodes.
+     * Note that partitions should always be numbered from {@code 0} inclusively to
+     * {@code N} exclusively without any gaps.
+     *
+     * @return Total partition count.
+     */
+    public int partitions();
+
+    /**
+     * Gets partition number for a given key starting from {@code 0}. Partitioned caches
+     * should make sure that keys are about evenly distributed across all partitions
+     * from {@code 0} to {@link #partitions() partition count} for best performance.
+     * <p>
+     * Note that for fully replicated caches it is possible to segment key sets among different
+     * grid node groups. In that case each node group should return a unique partition
+     * number. However, unlike partitioned cache, mappings of keys to nodes in
+     * replicated caches are constant and a node cannot migrate from one partition
+     * to another.
+     *
+     * @param key Key to get partition for.
+     * @return Partition number for a given key.
+     */
+    public int partition(Object key);
+
+    /**
+     * Gets affinity nodes for a partition. In case of replicated cache, all returned
+     * nodes are updated in the same manner. In case of partitioned cache, the returned
+     * list should contain only the primary and back up nodes with primary node being
+     * always first.
+     * <p>
+     * Note that partitioned affinity must obey the following contract: given that node
+     * <code>N</code> is primary for some key <code>K</code>, if any other node(s) leave
+     * grid and no node joins grid, node <code>N</code> will remain primary for key <code>K</code>.
+     *
+     * @param affCtx Affinity function context. Will provide all required information to calculate
+     *      new partition assignments.
+     * @return Unmodifiable list indexed by partition number. Each element of array is a collection in which
+     *      first node is a primary node and other nodes are backup nodes.
+     */
+    public List<List<ClusterNode>> assignPartitions(AffinityFunctionContext affCtx);
+
+    /**
+     * Removes node from affinity. This method is called when it is safe to remove left node from
+     * affinity mapping.
+     *
+     * @param nodeId ID of node to remove.
+     */
+    public void removeNode(UUID nodeId);
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunctionContext.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunctionContext.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunctionContext.java
new file mode 100644
index 0000000..9d22833
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityFunctionContext.java
@@ -0,0 +1,72 @@
+/*
+ * 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.affinity;
+
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.events.*;
+import org.apache.ignite.internal.processors.affinity.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ * Affinity function context. This context is passed to {@link AffinityFunction} for
+ * partition reassignment on every topology change event.
+ */
+public interface AffinityFunctionContext {
+    /**
+     * Gets affinity assignment for given partition on previous topology version. First node in returned list is
+     * a primary node, other nodes are backups.
+     *
+     * @param part Partition to get previous assignment for.
+     * @return List of nodes assigned to given partition on previous topology version or {@code null}
+     *      if this information is not available.
+     */
+    @Nullable public List<ClusterNode> previousAssignment(int part);
+
+    /**
+     * Gets number of backups for new assignment.
+     *
+     * @return Number of backups for new assignment.
+     */
+    public int backups();
+
+    /**
+     * Gets current topology snapshot. Snapshot will contain only nodes on which particular cache is configured.
+     * List of passed nodes is guaranteed to be sorted in a same order on all nodes on which partition assignment
+     * is performed.
+     *
+     * @return Cache topology snapshot.
+     */
+    public List<ClusterNode> currentTopologySnapshot();
+
+    /**
+     * Gets current topology version number.
+     *
+     * @return Current topology version number.
+     */
+    public AffinityTopologyVersion currentTopologyVersion();
+
+    /**
+     * Gets discovery event caused topology change.
+     *
+     * @return Discovery event caused latest topology change or {@code null} if this information is
+     *      not available.
+     */
+    @Nullable public DiscoveryEvent discoveryEvent();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKey.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKey.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKey.java
new file mode 100644
index 0000000..4e840f9
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKey.java
@@ -0,0 +1,189 @@
+/*
+ * 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.affinity;
+
+import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.util.tostring.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+
+import java.io.*;
+
+/**
+ * Optional wrapper for cache keys to provide support
+ * for custom affinity mapping. The value returned by
+ * {@link #affinityKey(Object)} method will be used for key-to-node
+ * affinity.
+ * <p>
+ * Note that the {@link #equals(Object)} and {@link #hashCode()} methods
+ * delegate directly to the wrapped cache key provided by {@link #key()}
+ * method.
+ * <p>
+ * This class is optional and does not have to be used. It only provides
+ * extra convenience whenever custom affinity mapping is required. Here is
+ * an example of how {@code Person} objects can be collocated with
+ * {@code Company} objects they belong to:
+ * <pre name="code" class="java">
+ * Object personKey = new AffinityKey(myPersonId, myCompanyId);
+ *
+ * // Both, the company and the person objects will be cached on the same node.
+ * cache.put(myCompanyId, new Company(..));
+ * cache.put(personKey, new Person(..));
+ * </pre>
+ * <p>
+ * For more information and examples of cache affinity refer to
+ * {@link AffinityKeyMapper} and {@link AffinityKeyMapped @AffinityKeyMapped}
+ * documentation.
+ * @see AffinityKeyMapped
+ * @see AffinityKeyMapper
+ * @see AffinityFunction
+ */
+public class AffinityKey<K> implements Externalizable {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Key. */
+    @GridToStringInclude
+    private K key;
+
+    /** Affinity key. */
+    @GridToStringInclude
+    private Object affKey;
+
+    /**
+     * Empty constructor.
+     */
+    public AffinityKey() {
+        // No-op.
+    }
+
+    /**
+     * Initializes key wrapper for a given key. If affinity key
+     * is not initialized, then this key will be used for affinity.
+     *
+     * @param key Key.
+     */
+    public AffinityKey(K key) {
+        A.notNull(key, "key");
+
+        this.key = key;
+    }
+
+    /**
+     * Initializes key together with its affinity key counter-part.
+     *
+     * @param key Key.
+     * @param affKey Affinity key.
+     */
+    public AffinityKey(K key, Object affKey) {
+        A.notNull(key, "key");
+
+        this.key = key;
+        this.affKey = affKey;
+    }
+
+    /**
+     * Gets wrapped key.
+     *
+     * @return Wrapped key.
+     */
+    public K key() {
+        return key;
+    }
+
+    /**
+     * Sets wrapped key.
+     *
+     * @param key Wrapped key.
+     */
+    public void key(K key) {
+        this.key = key;
+    }
+
+    /**
+     * Gets affinity key to use for affinity mapping. If affinity key is not provided,
+     * then {@code key} value will be returned.
+     * <p>
+     * This method is annotated with {@link AffinityKeyMapped} and will be picked up
+     * by {@link GridCacheDefaultAffinityKeyMapper} automatically.
+     *
+     * @return Affinity key to use for affinity mapping.
+     */
+    @AffinityKeyMapped
+    @SuppressWarnings({"unchecked"})
+    public <T> T affinityKey() {
+        A.notNull(key, "key");
+
+        return (T)(affKey == null ? key : affKey);
+    }
+
+    /**
+     * Sets affinity key to use for affinity mapping. If affinity key is not provided,
+     * then {@code key} value will be returned.
+     *
+     * @param affKey Affinity key to use for affinity mapping.
+     */
+    public void affinityKey(Object affKey) {
+        this.affKey = affKey;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void writeExternal(ObjectOutput out) throws IOException {
+        out.writeObject(key);
+        out.writeObject(affKey);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+        key = (K)in.readObject();
+        affKey = in.readObject();
+    }
+
+    /**
+     * Hash code implementation which delegates to the underlying {@link #key()}. Note, however,
+     * that different subclasses of {@link AffinityKey} will produce different hash codes.
+     * <p>
+     * Users should override this method if different behavior is desired.
+     *
+     * @return Hash code.
+     */
+    @Override public int hashCode() {
+        A.notNull(key, "key");
+
+        return 31 * key.hashCode() + getClass().getName().hashCode();
+    }
+
+    /**
+     * Equality check which delegates to the underlying key equality. Note, however, that
+     * different subclasses of {@link AffinityKey} will never be equal.
+     * <p>
+     * Users should override this method if different behavior is desired.
+     *
+     * @param obj Object to check for equality.
+     * @return {@code True} if objects are equal.
+     */
+    @Override public boolean equals(Object obj) {
+        A.notNull(key, "key");
+
+        return obj != null && getClass() == obj.getClass() && key.equals(((AffinityKey)obj).key);
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(AffinityKey.class, this);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapped.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapped.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapped.java
new file mode 100644
index 0000000..4464972
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapped.java
@@ -0,0 +1,110 @@
+/*
+ * 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.affinity;
+
+import java.lang.annotation.*;
+import java.util.concurrent.*;
+
+/**
+ * Optional annotation to specify custom key-to-node affinity. Affinity key is a key
+ * which will be used to determine a node on which given cache key will be stored. This
+ * annotation allows to mark a field or a method in the cache key object that will be
+ * used as an affinity key (instead of the entire cache key object that is used for
+ * affinity by default). Note that a class can have only one field or method annotated
+ * with {@code @AffinityKeyMapped} annotation.
+ * <p>
+ * One of the major use cases for this annotation is the routing of grid computations
+ * to the nodes where the data for this computation is cached, the concept
+ * otherwise known as {@code Collocation Of Computations And Data}.
+ * <p>
+ * <h1 class="header">Mapping Cache Keys</h1>
+ * The default implementation of {@link AffinityKeyMapper}, which will be used
+ * if no explicit affinity mapper is specified in cache configuration, will first look
+ * for any field or method annotated with {@code @AffinityKeyMapped} annotation.
+ * If such field or method is not found, then the cache key itself will be used for
+ * key-to-node affinity (this means that all objects with the same cache key will always
+ * be routed to the same node). If such field or method is found, then the value of this
+ * field or method will be used for key-to-node affinity. This allows to specify alternate
+ * affinity key, other than the cache key itself, whenever needed.
+ * <p>
+ * For example, if a {@code Person} object is always accessed together with a {@code Company} object
+ * for which this person is an employee, then for better performance and scalability it makes sense to
+ * collocate {@code Person} objects together with their {@code Company} object when storing them in
+ * cache. To achieve that, cache key used to cache {@code Person} objects should have a field or method
+ * annotated with {@code @AffinityKeyMapped} annotation, which will provide the value of
+ * the company key for which that person works, like so:
+ * <pre name="code" class="java">
+ * public class PersonKey {
+ *     // Person ID used to identify a person.
+ *     private String personId;
+ *
+ *     // Company ID which will be used for affinity.
+ *     &#64;AffinityKeyMapped
+ *     private String companyId;
+ *     ...
+ * }
+ * ...
+ * // Instantiate person keys.
+ * Object personKey1 = new PersonKey("myPersonId1", "myCompanyId");
+ * Object personKey2 = new PersonKey("myPersonId2", "myCompanyId");
+ *
+ * // Both, the company and the person objects will be cached on the same node.
+ * cache.put("myCompanyId", new Company(..));
+ * cache.put(personKey1, new Person(..));
+ * cache.put(personKey2, new Person(..));
+ * </pre>
+ * <p>
+ * <h2 class="header">AffinityKey</h2>
+ * For convenience, you can also optionally use {@link AffinityKey} class. Here is how a
+ * {@code PersonKey} defined above would look using {@link AffinityKey}:
+ * <pre name="code" class="java">
+ * Object personKey1 = new AffinityKey("myPersonId1", "myCompanyId");
+ * Object personKey2 = new AffinityKey("myPersonId2", "myCompanyId");
+ *
+ * // Both, the company and the person objects will be cached on the same node.
+ * cache.put(myCompanyId, new Company(..));
+ * cache.put(personKey1, new Person(..));
+ * cache.put(personKey2, new Person(..));
+ * </pre>
+ * <p>
+ * <h1 class="header">Collocating Computations And Data</h1>
+ * It is also possible to route computations to the nodes where the data is cached. This concept
+ * is otherwise known as {@code Collocation Of Computations And Data}. In this case,
+ * {@code @AffinityKeyMapped} annotation allows to specify a routing affinity key for a
+ * {@link org.apache.ignite.compute.ComputeJob} or any other grid computation, such as {@link Runnable},
+ * {@link Callable}, or {@link org.apache.ignite.lang.IgniteClosure}. It should be attached to a method or
+ * field that provides affinity key for the computation. Only one annotation per class is allowed.
+ * Whenever such annotation is detected, then {@link org.apache.ignite.spi.loadbalancing.LoadBalancingSpi}
+ * will be bypassed, and computation will be routed to the grid node where the specified affinity key is cached.
+ * <p>
+ * For more information about cache affinity also see {@link AffinityKeyMapper} and
+ * {@link AffinityFunction} documentation.
+ * Affinity for a key can be found from any node, regardless of whether it has cache started
+ * or not. If cache is not started, affinity function will be fetched from the remote node
+ * which does have the cache running.
+ *
+ * @see AffinityFunction
+ * @see AffinityKeyMapper
+ * @see AffinityKey
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.METHOD})
+public @interface AffinityKeyMapped {
+    // No-op.
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapper.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapper.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapper.java
new file mode 100644
index 0000000..69835c8
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityKeyMapper.java
@@ -0,0 +1,62 @@
+/*
+ * 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.affinity;
+
+import java.io.*;
+
+/**
+ * Affinity mapper which maps cache key to an affinity key. Affinity key is a key which will be
+ * used to determine a node on which this key will be cached. Every cache key will first be passed
+ * through {@link #affinityKey(Object)} method, and the returned value of this method
+ * will be given to {@link AffinityFunction} implementation to find out key-to-node affinity.
+ * <p>
+ * The default implementation, which will be used if no explicit affinity mapper is specified
+ * in cache configuration, will first look for any field or method annotated with
+ * {@link AffinityKeyMapped @AffinityKeyMapped} annotation. If such field or method
+ * is not found, then the cache key itself will be returned from {@link #affinityKey(Object) affinityKey(Object)}
+ * method (this means that all objects with the same cache key will always be routed to the same node).
+ * If such field or method is found, then the value of this field or method will be returned from
+ * {@link #affinityKey(Object) affinityKey(Object)} method. This allows to specify alternate affinity key, other
+ * than the cache key itself, whenever needed.
+ * <p>
+ * A custom (other than default) affinity mapper can be provided
+ * via {@link org.apache.ignite.configuration.CacheConfiguration#getAffinityMapper()} configuration property.
+ * <p>
+ * For more information on affinity mapping and examples refer to {@link AffinityFunction} and
+ * {@link AffinityKeyMapped @AffinityKeyMapped} documentation.
+ * @see AffinityFunction
+ * @see AffinityKeyMapped
+ */
+public interface AffinityKeyMapper extends Serializable {
+    /**
+     * Maps passed in key to an alternate key which will be used for node affinity.
+     *
+     * @param key Key to map.
+     * @return Key to be used for node-to-affinity mapping (may be the same
+     *      key as passed in).
+     */
+    public Object affinityKey(Object key);
+
+    /**
+     * Resets cache affinity mapper to its initial state. This method will be called by
+     * the system any time the affinity mapper has been sent to remote node where
+     * it has to be reinitialized. If your implementation of affinity mapper
+     * has no initialization logic, leave this method empty.
+     */
+    public void reset();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeAddressHashResolver.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeAddressHashResolver.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeAddressHashResolver.java
new file mode 100644
index 0000000..7ce49ec
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeAddressHashResolver.java
@@ -0,0 +1,39 @@
+/*
+ * 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.affinity;
+
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+
+/**
+ * Node hash resolver which uses {@link org.apache.ignite.cluster.ClusterNode#consistentId()} as alternate hash value.
+ */
+public class AffinityNodeAddressHashResolver implements AffinityNodeHashResolver {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** {@inheritDoc} */
+    @Override public Object resolve(ClusterNode node) {
+        return node.consistentId();
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(AffinityNodeAddressHashResolver.class, this);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeHashResolver.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeHashResolver.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeHashResolver.java
new file mode 100644
index 0000000..d00b043
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeHashResolver.java
@@ -0,0 +1,43 @@
+/*
+ * 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.affinity;
+
+import org.apache.ignite.cluster.*;
+
+import java.io.*;
+
+/**
+ * Resolver which is used to provide node hash value for affinity function.
+ * <p>
+ * Node IDs constantly change when nodes get restarted, which causes affinity mapping to change between restarts,
+ * and hence causing redundant repartitioning. Providing an alternate node hash value, which survives node restarts,
+ * will help to map keys to the same nodes whenever possible.
+ * <p>
+ * Note that on case clients exist they will query this object from the server and use it for affinity calculation.
+ * Therefore you must ensure that server and clients can marshal and unmarshal this object in portable format,
+ * i.e. all parties have object class(es) configured as portable.
+ */
+public interface AffinityNodeHashResolver extends Serializable {
+    /**
+     * Resolve alternate hash value for the given Grid node.
+     *
+     * @param node Grid node.
+     * @return Resolved hash ID.
+     */
+    public Object resolve(ClusterNode node);
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeIdHashResolver.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeIdHashResolver.java b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeIdHashResolver.java
new file mode 100644
index 0000000..65c6f13
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/affinity/AffinityNodeIdHashResolver.java
@@ -0,0 +1,40 @@
+/*
+ * 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.affinity;
+
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+
+/**
+ * Node hash resolver which uses generated node ID as node hash value. As new node ID is generated
+ * on each node start, this resolver do not provide ability to map keys to the same nodes after restart.
+ */
+public class AffinityNodeIdHashResolver implements AffinityNodeHashResolver {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** {@inheritDoc} */
+    @Override public Object resolve(ClusterNode node) {
+        return node.id();
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(AffinityNodeIdHashResolver.class, this);
+    }
+}


Mime
View raw message