This is an automated email from the ASF dual-hosted git repository. ivandasch pushed a commit to branch ignite-18494 in repository https://gitbox.apache.org/repos/asf/ignite.git
commit 43280272bf20a6af0402066eae75a63e455d22e9 Author: Ivan Daschinsky <[email protected]> AuthorDate: Wed Jan 11 18:23:12 2023 +0300 IGNITE-18494 Fix ignoring near cache configuration while starting cache not from affinity node. --- .../cache/DynamicCacheChangeRequest.java | 3 + .../near/GridCacheNearDynamicStartTest.java | 157 +++++++++++++++++++++ .../ignite/testsuites/IgniteCacheTestSuite2.java | 2 + 3 files changed, 162 insertions(+) diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/DynamicCacheChangeRequest.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/DynamicCacheChangeRequest.java index 399c2cd1c77..e0e6037a856 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/DynamicCacheChangeRequest.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/DynamicCacheChangeRequest.java @@ -371,6 +371,9 @@ public class DynamicCacheChangeRequest implements Serializable { */ public void startCacheConfiguration(CacheConfiguration startCfg) { this.startCfg = startCfg; + + if (startCfg.getNearConfiguration() != null) + nearCacheCfg = startCfg.getNearConfiguration(); } /** diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearDynamicStartTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearDynamicStartTest.java new file mode 100644 index 00000000000..3f43e5710f9 --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearDynamicStartTest.java @@ -0,0 +1,157 @@ +/* + * 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.internal.processors.cache.distributed.near; + +import java.util.ArrayList; +import java.util.List; +import java.util.TreeMap; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import org.apache.ignite.Ignite; +import org.apache.ignite.IgniteCache; +import org.apache.ignite.cache.CachePeekMode; +import org.apache.ignite.configuration.CacheConfiguration; +import org.apache.ignite.configuration.IgniteConfiguration; +import org.apache.ignite.configuration.NearCacheConfiguration; +import org.apache.ignite.internal.IgniteEx; +import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +/** + * Tests that dynamically started caches with near configurations actually start with near caches on all nodes: + * affinity, non-affinity and clients. + */ +@RunWith(Parameterized.class) +public class GridCacheNearDynamicStartTest extends GridCommonAbstractTest { + /** */ + private static final int SRV_CNT = 3; + + /** */ + private static final String CLIENT_ID = "client"; + + /** */ + @Parameterized.Parameters(name = "nodeCacheStart = {0}, nodeNearCheck = {1}") + public static Iterable<Object[]> useBinaryArrays() { + List<Object[]> params = new ArrayList<>(); + + for (NODE_TYPE nodeStart: NODE_TYPE.values()) { + for (NODE_TYPE nodeNearCheck: NODE_TYPE.values()) + params.add(new Object[]{ nodeStart, nodeNearCheck}); + } + + return params; + } + + /** */ + @Parameterized.Parameter(0) + public NODE_TYPE nodeStart; + + /** */ + @Parameterized.Parameter(1) + public NODE_TYPE nodeCheck; + + /** {@inheritDoc} */ + @Override protected void beforeTestsStarted() throws Exception { + startGrids(SRV_CNT); + startClientGrid(CLIENT_ID); + } + + /** {@inheritDoc} */ + @Override protected void afterTest() throws Exception { + IgniteEx ign = grid(0); + + ign.cacheNames().forEach(ign::destroyCache); + } + + /** {@inheritDoc} */ + @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { + return super.getConfiguration(igniteInstanceName).setConsistentId(igniteInstanceName); + } + + /** */ + @Test + public void test() throws Exception { + startCache(); + + IgniteEx ign = testNode(nodeCheck); + + IntStream.range(0, 1000).boxed().forEach(i -> { + IgniteCache<Integer, Integer> cache = ign.cache(DEFAULT_CACHE_NAME); + + assertEquals(i, cache.get(i)); + + if (ign.affinity(DEFAULT_CACHE_NAME).isPrimary(ign.localNode(), i)) + return; + + assertEquals(i, cache.localPeek(i, CachePeekMode.NEAR)); + }); + } + + /** */ + private void startCache() { + Ignite ign = testNode(nodeStart); + + IgniteCache<Integer, Integer> cache = ign.createCache( + new CacheConfiguration<Integer, Integer>(DEFAULT_CACHE_NAME) + .setNodeFilter(n -> { + if (n.consistentId() == null) + return false; + + // Start cache on nodes with indices [0, 1]. + return !n.consistentId().toString().contains(String.valueOf(SRV_CNT - 1)); + }) + .setNearConfiguration(new NearCacheConfiguration<>()) + ); + + cache.putAll( + IntStream.range(0, 1000).boxed().collect( + Collectors.toMap(Function.identity(), Function.identity(), (i, j) -> i, TreeMap::new) + ) + ); + + assertEquals(ign.cache(DEFAULT_CACHE_NAME).size(CachePeekMode.PRIMARY), 1000); + } + + /** */ + private IgniteEx testNode(NODE_TYPE type) { + switch (type) { + case AFFINITY: + return grid(SRV_CNT - 2); + case NON_AFFINITY: + return grid(SRV_CNT - 1); + case CLIENT: + default: + return grid(CLIENT_ID); + } + } + + /** */ + private enum NODE_TYPE { + /** Affinity node. */ + AFFINITY, + + /** Non affinity node. */ + NON_AFFINITY, + + /** Client node. */ + CLIENT, + } +} diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite2.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite2.java index b3ca245f7ba..0c44992d8e4 100644 --- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite2.java +++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite2.java @@ -114,6 +114,7 @@ import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheAto import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheAtomicNearMultiNodeSelfTest; import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheAtomicNearReadersSelfTest; import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheNearClientHitTest; +import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheNearDynamicStartTest; import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheNearEvictionEventSelfTest; import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheNearJobExecutionSelfTest; import org.apache.ignite.internal.processors.cache.distributed.near.GridCacheNearMultiGetSelfTest; @@ -266,6 +267,7 @@ public class IgniteCacheTestSuite2 { GridTestUtils.addTestIfNeeded(suite, GridCacheOffheapUpdateSelfTest.class, ignoredTests); GridTestUtils.addTestIfNeeded(suite, GridCacheNearClientHitTest.class, ignoredTests); + GridTestUtils.addTestIfNeeded(suite, GridCacheNearDynamicStartTest.class, ignoredTests); GridTestUtils.addTestIfNeeded(suite, GridCacheNearPrimarySyncSelfTest.class, ignoredTests); GridTestUtils.addTestIfNeeded(suite, GridCacheColocatedPrimarySyncSelfTest.class, ignoredTests);
