/** * Check isBackup, isPrimary and isPrimaryOrBackup methods. * * @param testAff Affinity1. * @param aff Affinity2. */ private void checkIsBackupOrPrimary(Affinity testAff, Affinity aff) { for (int i = 0; i < 10000; i++) for (ClusterNode n : nodes()) { assertEquals(testAff.isBackup(n, i), aff.isBackup(n, i)); assertEquals(testAff.isPrimary(n, i), aff.isPrimary(n, i)); assertEquals(testAff.isPrimaryOrBackup(n, i), aff.isPrimaryOrBackup(n, i)); } }
/** * Maps affinity key to node. * * @param affinityKey Affinity key to map. * @return Primary node for this key. */ public ClusterNode affinityNode(Object affinityKey) { return dataCache.affinity().mapKeyToNode(affinityKey); }
/** * Check mapPartitionToPrimaryAndBackups and mapPartitionToNode methods. * * @param testAff Affinity1. * @param aff Affinity2. */ private void checkMapPartitionToNode(Affinity testAff, Affinity aff) { assertEquals(aff.partitions(), testAff.partitions()); for (int part = 0; part < aff.partitions(); ++part) { assertEquals(testAff.mapPartitionToNode(part).id(), aff.mapPartitionToNode(part).id()); checkEqualCollection(testAff.mapPartitionToPrimaryAndBackups(part), aff.mapPartitionToPrimaryAndBackups(part)); } }
/** * Check mapPartitionsToNodes methods. * * @param testAff Affinity1. * @param aff Affinity2. */ private void checkMapPartitionsToNodes(Affinity testAff, Affinity aff) { List<Integer> parts = new ArrayList<>(aff.partitions()); for (int i = 0; i < aff.partitions(); ++i) parts.add(i); checkEqualPartitionMaps(testAff.mapPartitionsToNodes(parts), aff.mapPartitionsToNodes(parts)); }
/** * Checks if affinity mapping has been changed. * * @return True if mapping has been changed, otherwise false. */ private boolean hasAffinityChanged() { Affinity<?> affinity = ignite.affinity(jobArchive.getUpstreamCacheName()); int parts = affinity.partitions(); UUID[] ids = new UUID[parts]; for (int part = 0; part < parts; part++) { ClusterNode node = affinity.mapPartitionToNode(part); UUID nodeId = node.id(); ids[part] = nodeId; } if (prev == null || !Arrays.equals(ids, prev)) { prev = ids; return true; } return false; }
int[] parts = node != null ? aff.primaryPartitions(node) : U.EMPTY_INTS; int[] parts = node != null ? aff.backupPartitions(node) : U.EMPTY_INTS; int[] parts = node != null ? aff.allPartitions(node) : U.EMPTY_INTS; Object key = reader.readObjectDetached(); writer.writeObject(aff.affinityKey(key)); Object key = reader.readObjectDetached(); ClusterNode node = aff.mapKeyToNode(key); int part = reader.readObject(); ClusterNode node = aff.mapPartitionToNode(part); Object key = reader.readObjectDetached(); platformCtx.writeNodes(writer, aff.mapKeyToPrimaryAndBackups(key)); platformCtx.writeNodes(writer, aff.mapPartitionToPrimaryAndBackups(part)); Map<ClusterNode, Collection<Object>> map = aff.mapKeysToNodes(keys); Map<Integer, ClusterNode> map = aff.mapPartitionsToNodes(parts);
/** * @param key Key to check. * @param val Expected value. */ private void checkValues(int key, int val) { for (int i = 0; i < 3; i++) { IgniteEx grid = grid(i); ClusterNode node = grid.localNode(); IgniteCache<Object, Object> cache = grid.cache(DEFAULT_CACHE_NAME); boolean primary = grid.affinity(DEFAULT_CACHE_NAME).isPrimary(node, key); boolean backup = grid.affinity(DEFAULT_CACHE_NAME).isBackup(node, key); if (primary || backup) assertEquals("Invalid cache value [nodeId=" + node.id() + ", primary=" + primary + ", backup=" + backup + ", key=" + key + ']', val, cache.localPeek(key, CachePeekMode.ONHEAP)); } }
/** * @param cacheName Cache name. * @param expNodes Expected number of nodes per partition. */ private void checkCache(String cacheName, int expNodes) { log.info("Test cache: " + cacheName); Affinity<Object> aff0 = ignite(0).affinity(cacheName); Ignite client = ignite(NODE_CNT - 1); assertTrue(client.configuration().isClientMode()); ClusterNode clientNode = client.cluster().localNode(); for (int i = 0; i < NODE_CNT; i++) { Ignite ignite = ignite(i); Affinity<Object> aff = ignite.affinity(cacheName); for (int part = 0; part < aff.partitions(); part++) { Collection<ClusterNode> nodes = aff.mapPartitionToPrimaryAndBackups(part); assertEquals(expNodes, nodes.size()); assertEquals(aff0.mapPartitionToPrimaryAndBackups(part), nodes); assertFalse(nodes.contains(clientNode)); assertEquals(aff0.partition(part), aff.partition(part)); TestKey key = new TestKey(part, part + 1); assertEquals(aff0.partition(key), aff.partition(key)); assertEquals(aff0.mapKeyToPrimaryAndBackups(key), aff.mapKeyToPrimaryAndBackups(key)); } } }
@Override public Object call() throws Exception { return affinity.isPrimary(n, key); } }, IgniteException.class, EXPECTED_MSG);
/** {@inheritDoc} */ @Override public long processInLongOutLong(int type, long val) throws IgniteCheckedException { if (type == OP_PARTITIONS) return aff.partitions(); return super.processInLongOutLong(type, val); } }
/** * @param aff Affinity. * @param key Key. * @return Backup node for given key. */ private Ignite backup(Affinity<Object> aff, Object key) { for (Ignite ignite : G.allGrids()) { ClusterNode node = ignite.cluster().localNode(); if (aff.isPrimaryOrBackup(node, key) && !aff.isPrimary(node, key)) return ignite; } fail("Failed to find backup for key: " + key); return null; }
/** * @throws IgniteCheckedException If failed. */ @Test public void testAffinity() throws Exception { Ignite g1 = grid(1); Ignite g2 = grid(2); assert caches(g1).isEmpty(); assert F.first(caches(g2)).getCacheMode() == PARTITIONED; awaitPartitionMapExchange(); Map<ClusterNode, Collection<String>> map = g1.<String>affinity(DEFAULT_CACHE_NAME).mapKeysToNodes(F.asList("1")); assertNotNull(map); assertEquals("Invalid map size: " + map.size(), 1, map.size()); assertEquals(F.first(map.keySet()), g2.cluster().localNode()); UUID id1 = g1.affinity(DEFAULT_CACHE_NAME).mapKeyToNode("2").id(); assertNotNull(id1); assertEquals(g2.cluster().localNode().id(), id1); UUID id2 = g1.affinity(DEFAULT_CACHE_NAME).mapKeyToNode("3").id(); assertNotNull(id2); assertEquals(g2.cluster().localNode().id(), id2); }
/** * Check mapKeyToNode, mapKeyToPrimaryAndBackups methods. * * @param testAff Affinity1. * @param aff Affinity2. */ private void checkMapKeyToNode(Affinity testAff, Affinity aff) { for (int i = 0; i < 10000; i++) { assertEquals(testAff.mapKeyToNode(i).id(), aff.mapKeyToNode(i).id()); checkEqualCollection(testAff.mapKeyToPrimaryAndBackups(i), aff.mapKeyToPrimaryAndBackups(i)); } }
/** * * @param ignite Grid * @param key Key. * @return Primary node id. */ @SuppressWarnings("unchecked") private static UUID primaryId(Ignite ignite, Object key) { Affinity aff = ignite.affinity(DEFAULT_CACHE_NAME); Collection<ClusterNode> affNodes = aff.mapPartitionToPrimaryAndBackups(aff.partition(key)); ClusterNode first = F.first(affNodes); assert first != null; return first.id(); }
/** * Maps affinity key to node. * * @param affinityKey Affinity key to map. * @return Primary node for this key. */ public Collection<ClusterNode> affinityNodes(Object affinityKey) { return dataCache.affinity().mapKeyToPrimaryAndBackups(affinityKey); }
/** {@inheritDoc} */ @Override public Map<ClusterNode, Collection<K>> mapKeysToNodes(@Nullable Collection<? extends K> keys) { CacheOperationContext old = gate.enter(null); try { return delegate.mapKeysToNodes(keys); } finally { gate.leave(old); } }
@Override public Object call() throws Exception { return affinity.isPrimaryOrBackup(n, key); } }, IgniteException.class, EXPECTED_MSG);
@Override public Object call() throws Exception { return affinity.mapPartitionsToNodes(Collections.singleton(0)); } }, IgniteException.class, EXPECTED_MSG);
@Override public Object call() throws Exception { return affinity.mapPartitionToPrimaryAndBackups(0); } }, IgniteException.class, EXPECTED_MSG);
/** * @param key Key. * @return For the given key pair {primary node, some other node}. */ private IgniteBiTuple<ClusterNode, ClusterNode> getNodes(Integer key) { Affinity<Integer> aff = grid(0).affinity(DEFAULT_CACHE_NAME); int part = aff.partition(key); ClusterNode primary = aff.mapPartitionToNode(part); assert primary != null; Collection<ClusterNode> nodes = new ArrayList<>(grid(0).cluster().nodes()); nodes.remove(primary); ClusterNode other = F.first(nodes); assert other != null; assert !F.eqNodes(primary, other); return F.t(primary, other); } }