anton-vinogradov commented on code in PR #13627:
URL: https://github.com/apache/ignite/pull/13627#discussion_r4539821468


##########
modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/preloader/GridDhtPartitionsExchangeFuture.java:
##########
@@ -2391,8 +2394,21 @@ private String exchangeTimingsLogMessage(String header, 
List<String> timings) {
 
                 cleanIdxRebuildFutures = false;
 
-                for (CacheGroupContext grp : cctx.cache().cacheGroups())
-                    grp.topology().onExchangeDone(this, 
grp.affinity().readyAffinity(res), false);
+                for (CacheGroupContext grp : cctx.cache().cacheGroups()) {
+                    if (grp.topology().onExchangeDone(this, 
grp.affinity().readyAffinity(res), false))
+                        locChangedGrps.add(grp);
+                }
+
+                if (!locChangedGrps.isEmpty()
+                    && 
cctx.kernalContext().rollingUpgrade().features().isActive(PART_STATE_FROM_OWNER_FEATURE))
 {

Review Comment:
   I read the compatibility mode as covering what older nodes can't handle, 
like the commands and message fields behind the existing features: this map is 
an ordinary single message that any version already sends, for example after an 
eviction. In the middle state the other nodes write the owner's state and then 
get the same state from the owner, so the maps converge, the race is fixed 
during the upgrade too, and the resend on activation isn't needed.



##########
modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java:
##########
@@ -524,6 +526,18 @@ public void onCoordinatorInitialized() {
      * @param cache Cache.
      */
     public void onLocalJoin(DiscoveryEvent evt, DiscoCache cache) {
+        IgniteFeatureManager features = 
cctx.kernalContext().rollingUpgrade().features();
+
+        boolean activationAhead = !cctx.kernalContext().clientNode()
+            && 
features.localVersionFeatures().contains(PART_STATE_FROM_OWNER_FEATURE)
+            && !features.isActive(PART_STATE_FROM_OWNER_FEATURE);
+
+        // On activation every server resends its maps once: an owner that 
finished its last exchange before the
+        // activation didn't send its map, and the other nodes no longer write 
its state. A node that emulates an older
+        // version in tests lacks the feature, and listenActivation() requires 
it.
+        if (activationAhead)
+            features.listenActivation(PART_STATE_FROM_OWNER_FEATURE, 
this::scheduleResendPartitions);
+

Review Comment:
   With the resend in onDone always on, every owner has already sent its map by 
the activation. Please drop this listener; the PR tests pass without it.
   ```suggestion
   ```



##########
modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java:
##########
@@ -161,6 +162,7 @@
 import static 
org.apache.ignite.internal.processors.metric.GridMetricManager.PME_OPS_BLOCKED_DURATION;
 import static 
org.apache.ignite.internal.processors.metric.GridMetricManager.PME_OPS_BLOCKED_DURATION_HISTOGRAM;
 import static 
org.apache.ignite.internal.processors.metric.GridMetricManager.REBALANCED;
+import static 
org.apache.ignite.internal.processors.rollingupgrade.feature.CoreFeatureRegistry.PART_STATE_FROM_OWNER_FEATURE;

Review Comment:
   Unused without the listener.
   ```suggestion
   ```



##########
modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java:
##########
@@ -104,6 +104,7 @@
 import org.apache.ignite.internal.processors.metric.impl.BooleanMetricImpl;
 import org.apache.ignite.internal.processors.metric.impl.HistogramMetricImpl;
 import 
org.apache.ignite.internal.processors.query.schema.SchemaNodeLeaveExchangeWorkerTask;
+import 
org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteFeatureManager;

Review Comment:
   Unused without the listener.
   ```suggestion
   ```



##########
modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/PartitionStateFromOwnerRollingUpgradeTest.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.internal.processors.cache.distributed;
+
+import java.util.List;
+import java.util.UUID;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.TestRecordingCommunicationSpi;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleMessage;
+import 
org.apache.ignite.internal.processors.rollingupgrade.AbstractRollingUpgradeTest;
+import org.apache.ignite.internal.util.typedef.G;
+import org.apache.ignite.plugin.extensions.communication.Message;
+import org.junit.Test;
+
+import static org.apache.ignite.cache.PartitionLossPolicy.IGNORE;
+import static 
org.apache.ignite.internal.processors.cache.distributed.CachePartitionLossStaleMapTest.exchangeFinished;
+import static 
org.apache.ignite.internal.processors.cache.distributed.CachePartitionLossStaleMapTest.mismatches;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPreloader.DFLT_PRELOAD_RESEND_TIMEOUT;

Review Comment:
   Unused without the activation check.
   ```suggestion
   ```



##########
modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/PartitionStateFromOwnerRollingUpgradeTest.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.internal.processors.cache.distributed;
+
+import java.util.List;
+import java.util.UUID;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.TestRecordingCommunicationSpi;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleMessage;
+import 
org.apache.ignite.internal.processors.rollingupgrade.AbstractRollingUpgradeTest;
+import org.apache.ignite.internal.util.typedef.G;
+import org.apache.ignite.plugin.extensions.communication.Message;
+import org.junit.Test;
+
+import static org.apache.ignite.cache.PartitionLossPolicy.IGNORE;
+import static 
org.apache.ignite.internal.processors.cache.distributed.CachePartitionLossStaleMapTest.exchangeFinished;
+import static 
org.apache.ignite.internal.processors.cache.distributed.CachePartitionLossStaleMapTest.mismatches;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPreloader.DFLT_PRELOAD_RESEND_TIMEOUT;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
+
+/**
+ * Checks that until {@code PART_STATE_FROM_OWNER_FEATURE} is active the nodes 
handle lost partitions as the previous
+ * version does: the other nodes write the new owners' state into their 
partition maps themselves. Once the feature is
+ * active, they take it from the owners' maps.
+ * <p>
+ * In both parts a server leaves with the only copies of some partitions under 
the IGNORE policy, while the maps that
+ * the other servers send outside an exchange are held, so the coordinator 
sees only the state it wrote itself. The
+ * coordinator and the client watch the new owners' partitions. The client 
hasn't started the cache, so it keeps the
+ * cache's partition map in a client topology.
+ */
+public class PartitionStateFromOwnerRollingUpgradeTest extends 
AbstractRollingUpgradeTest {
+    /** */
+    private static final String CACHE = "cache";
+
+    /** */
+    private static final int PARTS = 64;
+
+    /** Version without {@code PART_STATE_FROM_OWNER_FEATURE}. */
+    private static final String OLD_VER = "2.18.0";
+
+    /** Index of the client node, as started by {@link #startCluster(String)}. 
*/
+    private static final int CLIENT = 2;
+
+    /** Index of the server that leaves. */
+    private static final int LEAVING = 3;
+
+    /** Time to wait for the partition maps to match, in milliseconds. */
+    private static final long WAIT = 30_000;
+
+    /**
+     * Before the upgrade the coordinator and the client see the new owners 
right after the exchange, with the owners'
+     * maps held. Once all nodes are upgraded and the version is finalized, 
the feature is active, and they see the new
+     * owners only after the maps arrive. On activation a server resends its 
maps, and a client doesn't.
+     *
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testOwnersReportStateAfterUpgrade() throws Exception {
+        startCluster(OLD_VER);
+        startGrid(LEAVING, OLD_VER);
+
+        grid(0).createCache(new CacheConfiguration<Integer, Integer>(CACHE)
+            .setBackups(0)
+            .setPartitionLossPolicy(IGNORE)
+            .setAffinity(new RendezvousAffinityFunction(false, PARTS)));
+
+        awaitPartitionMapExchange();
+
+        IgniteEx oldCrd = stopLeavingWithMapsHeld();
+
+        for (IgniteEx viewer : new IgniteEx[] {oldCrd, grid(CLIENT)}) {
+            List<String> mismatches = mismatches(viewer, CACHE);
+
+            assertTrue(viewer.name() + " didn't write the new owners' state: " 
+ mismatches, mismatches.isEmpty());
+        }
+
+        for (Ignite g : G.allGrids()) {
+            if (g != oldCrd && !g.cluster().localNode().isClient()) {
+                assertFalse(g.name() + " sent its partition map before the 
feature is active",
+                    TestRecordingCommunicationSpi.spi(g).hasBlockedMessages());
+            }
+        }
+
+        TestRecordingCommunicationSpi.stopBlockAll();
+
+        ru(0).enableVersionUpgrade();
+
+        upgradeNodeVersion(1, OLD_VER, MASTER_VER_REF);
+        upgradeNodeVersion(CLIENT, OLD_VER, MASTER_VER_REF);
+        upgradeNodeVersion(0, OLD_VER, MASTER_VER_REF);
+
+        awaitPartitionMapExchange();
+
+        TestRecordingCommunicationSpi srvSpi = 
TestRecordingCommunicationSpi.spi(grid(coordinatorIndex() == 0 ? 1 : 0));
+        TestRecordingCommunicationSpi clientSpi = 
TestRecordingCommunicationSpi.spi(grid(CLIENT));
+
+        srvSpi.record((node, msg) -> sentOutsideExchange(msg));
+        clientSpi.record((node, msg) -> sentOutsideExchange(msg));
+
+        // Also checks that every node has the features of the new version 
active.
+        finalizeClusterVersion(1, MASTER_VER_REF);
+
+        assertTrue("The server didn't resend its partition map on activation",
+            waitForCondition(() -> !srvSpi.recordedMessages(false).isEmpty(), 
WAIT));
+
+        assertFalse("The client resent its partition map on activation",
+            waitForCondition(() -> 
!clientSpi.recordedMessages(false).isEmpty(), DFLT_PRELOAD_RESEND_TIMEOUT));
+

Review Comment:
   Without the listener there is no resend on activation to check.
   ```suggestion
           // Also checks that every node has the features of the new version 
active.
           finalizeClusterVersion(1, MASTER_VER_REF);
   
   ```



##########
modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CachePartitionLossStaleMapTest.java:
##########
@@ -0,0 +1,600 @@
+/*
+ * 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;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteException;
+import org.apache.ignite.cache.PartitionLossPolicy;
+import org.apache.ignite.cache.affinity.AffinityFunction;
+import org.apache.ignite.cache.affinity.AffinityFunctionContext;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.NodeStoppingException;
+import org.apache.ignite.internal.TestRecordingCommunicationSpi;
+import org.apache.ignite.internal.managers.communication.GridIoMessage;
+import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
+import org.apache.ignite.internal.processors.cache.IgniteInternalCache;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionMap;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleMessage;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.EvictionContext;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtLocalPartition;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionTopology;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionTopologyImpl;
+import org.apache.ignite.internal.processors.resource.DependencyResolver;
+import org.apache.ignite.internal.util.typedef.G;
+import org.apache.ignite.internal.util.typedef.internal.CU;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.lang.IgniteInClosure;
+import org.apache.ignite.plugin.extensions.communication.Message;
+import org.apache.ignite.spi.IgniteSpiException;
+import org.apache.ignite.testframework.TestDependencyResolver;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.junit.Test;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.apache.ignite.cache.PartitionLossPolicy.IGNORE;
+import static org.apache.ignite.cache.PartitionLossPolicy.READ_WRITE_SAFE;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.EVICTED;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.MOVING;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.RENTING;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
+
+/**
+ * Checks that partition maps match the local partition states of the nodes 
after a node leaves with the only copy of
+ * some partitions.
+ * <p>
+ * The new primary recreates each lost partition empty as MOVING when it 
applies the coordinator's full message. At
+ * the end of the exchange it owns the partition under the {@link 
PartitionLossPolicy#IGNORE IGNORE} policy or marks
+ * it LOST under the safe policies. Only the new primary writes this state 
into its partition map and sends the map.
+ * A map the node sent earlier shows the partition MOVING or doesn't have it 
at all. The other nodes must take the
+ * new primary's state in the end, whatever order its maps arrive in.
+ * <p>
+ * In a real cluster such an earlier map is a resend scheduled by {@code 
scheduleResendPartitions()}, for example after
+ * an eviction. {@link #testStaleCoordinatorMapAfterEviction()} checks the 
case where the coordinator is the new
+ * primary.
+ */
+public class CachePartitionLossStaleMapTest extends GridCommonAbstractTest {
+    /** */
+    protected static final String CACHE = "cache";
+
+    /** */
+    private static final int PARTS = 64;
+
+    /** Index of the node that sends a stale partition map before it owns a 
lost partition or marks it LOST. */
+    private static final int STALE_MAP_SENDER = 1;
+
+    /** Index of the node that leaves. */
+    private static final int LEAVING = 2;
+
+    /** Index of a server node that watches node 1's partitions in its 
partition map. */
+    private static final int OBSERVER = 3;
+
+    /** Index of the client node. */
+    private static final int CLIENT = 4;

Review Comment:
   For testJoinWhileLost below.
   ```suggestion
       private static final int CLIENT = 4;
   
       /** Index of the node that joins while partitions are lost. */
       private static final int JOINING = 5;
   ```



##########
modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CachePartitionLossStaleMapTest.java:
##########
@@ -0,0 +1,600 @@
+/*
+ * 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;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteException;
+import org.apache.ignite.cache.PartitionLossPolicy;
+import org.apache.ignite.cache.affinity.AffinityFunction;
+import org.apache.ignite.cache.affinity.AffinityFunctionContext;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.NodeStoppingException;
+import org.apache.ignite.internal.TestRecordingCommunicationSpi;
+import org.apache.ignite.internal.managers.communication.GridIoMessage;
+import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
+import org.apache.ignite.internal.processors.cache.IgniteInternalCache;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionMap;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleMessage;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.EvictionContext;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtLocalPartition;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionTopology;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionTopologyImpl;
+import org.apache.ignite.internal.processors.resource.DependencyResolver;
+import org.apache.ignite.internal.util.typedef.G;
+import org.apache.ignite.internal.util.typedef.internal.CU;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.lang.IgniteInClosure;
+import org.apache.ignite.plugin.extensions.communication.Message;
+import org.apache.ignite.spi.IgniteSpiException;
+import org.apache.ignite.testframework.TestDependencyResolver;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.junit.Test;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.apache.ignite.cache.PartitionLossPolicy.IGNORE;
+import static org.apache.ignite.cache.PartitionLossPolicy.READ_WRITE_SAFE;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.EVICTED;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.MOVING;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.RENTING;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
+
+/**
+ * Checks that partition maps match the local partition states of the nodes 
after a node leaves with the only copy of
+ * some partitions.
+ * <p>
+ * The new primary recreates each lost partition empty as MOVING when it 
applies the coordinator's full message. At
+ * the end of the exchange it owns the partition under the {@link 
PartitionLossPolicy#IGNORE IGNORE} policy or marks
+ * it LOST under the safe policies. Only the new primary writes this state 
into its partition map and sends the map.
+ * A map the node sent earlier shows the partition MOVING or doesn't have it 
at all. The other nodes must take the
+ * new primary's state in the end, whatever order its maps arrive in.
+ * <p>
+ * In a real cluster such an earlier map is a resend scheduled by {@code 
scheduleResendPartitions()}, for example after
+ * an eviction. {@link #testStaleCoordinatorMapAfterEviction()} checks the 
case where the coordinator is the new
+ * primary.
+ */
+public class CachePartitionLossStaleMapTest extends GridCommonAbstractTest {
+    /** */
+    protected static final String CACHE = "cache";
+
+    /** */
+    private static final int PARTS = 64;
+
+    /** Index of the node that sends a stale partition map before it owns a 
lost partition or marks it LOST. */
+    private static final int STALE_MAP_SENDER = 1;
+
+    /** Index of the node that leaves. */
+    private static final int LEAVING = 2;
+
+    /** Index of a server node that watches node 1's partitions in its 
partition map. */
+    private static final int OBSERVER = 3;
+
+    /** Index of the client node. */
+    private static final int CLIENT = 4;
+
+    /** Time to wait for a step of a test, in milliseconds. */
+    private static final long WAIT = 30_000;
+
+    /**
+     * When set, the new primary sends its partition map right before it owns 
a MOVING partition of the cache or marks
+     * it LOST.
+     */
+    private final AtomicBoolean sendBeforeChange = new AtomicBoolean();
+
+    /** When set, the next eviction of a partition of the cache waits for 
{@link #evictionResume}. */
+    private final AtomicBoolean holdEviction = new AtomicBoolean();
+
+    /** Counted down when an eviction starts waiting. */
+    private final CountDownLatch evictionHeld = new CountDownLatch(1);
+
+    /** Lets the held eviction go on. */
+    private final CountDownLatch evictionResume = new CountDownLatch(1);
+
+    /** When set, the coordinator waits for {@link #crdResume} right after it 
sends the next exchange full message. */
+    private final AtomicBoolean stallAfterFullMsg = new AtomicBoolean();
+
+    /** Counted down when the coordinator starts waiting. */
+    private final CountDownLatch crdStalled = new CountDownLatch(1);
+
+    /** Lets the coordinator go on. */
+    private final CountDownLatch crdResume = new CountDownLatch(1);
+
+    /** Partition loss policy of the cache. */
+    private PartitionLossPolicy plc = IGNORE;
+
+    /**
+     * Whether the coordinator is the new primary of all lost partitions. Sets 
{@link JoinOrderAffinityFunction} and a
+     * {@link StallingCommunicationSpi}.
+     */
+    private boolean crdNewPrimary;
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String 
igniteInstanceName) throws Exception {
+        IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);
+
+        cfg.setCacheConfiguration(new CacheConfiguration<Integer, 
Integer>(CACHE)
+            .setBackups(0)
+            .setPartitionLossPolicy(plc)
+            .setAffinity(crdNewPrimary
+                ? new JoinOrderAffinityFunction()
+                : new RendezvousAffinityFunction(false, PARTS)));
+
+        cfg.setCommunicationSpi(crdNewPrimary ? new StallingCommunicationSpi() 
: new TestRecordingCommunicationSpi());
+
+        // Evictions run in the rebalance pool, one thread by default below 8 
cores: a held one would block the rest.
+        cfg.setRebalanceThreadPoolSize(4);
+
+        return cfg;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTest() throws Exception {
+        evictionResume.countDown();
+        crdResume.countDown();
+
+        stopAllGrids();
+
+        super.afterTest();
+    }
+
+    /**
+     * Node 1 sends a stale map before it owns a lost partition under the 
IGNORE policy.
+     *
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testStaleMapBeforeLostPartitionOwned() throws Exception {
+        checkStaleMapBeforeLostPartitionChanged(IGNORE);
+    }
+
+    /**
+     * Node 1 sends a stale map before it marks a lost partition LOST under 
the READ_WRITE_SAFE policy.
+     *
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testStaleMapBeforeLostPartitionMarkedLost() throws Exception {
+        checkStaleMapBeforeLostPartitionChanged(READ_WRITE_SAFE);
+    }
+
+    /**
+     * Checks that the partition maps of the coordinator, the observer and the 
client match the local states of the
+     * nodes after node 1 sends a stale map. Node 2 joins, takes over 
partitions from the other servers, and leaves with
+     * the only copies. Right before node 1 owns a lost partition or marks it 
LOST, it sends its map, which still shows
+     * the partition MOVING. The coordinator gets this map once its own 
exchange is finished, and the check starts once
+     * the coordinator has taken it.
+     *
+     * @param plc Partition loss policy.
+     * @throws Exception If failed.
+     */
+    private void checkStaleMapBeforeLostPartitionChanged(PartitionLossPolicy 
plc) throws Exception {
+        this.plc = plc;
+
+        IgniteEx crd = startNodes();
+
+        awaitPartitionMapExchange(true, true, null);
+
+        UUID crdId = crd.localNode().id();
+
+        TestRecordingCommunicationSpi sndSpi = 
TestRecordingCommunicationSpi.spi(grid(STALE_MAP_SENDER));
+
+        // Hold node 1's maps sent outside an exchange until the coordinator 
finishes the exchange.
+        sndSpi.blockMessages((node, msg) -> node.id().equals(crdId)
+            && msg instanceof GridDhtPartitionsSingleMessage
+            && ((GridDhtPartitionsSingleMessage)msg).exchangeId() == null);
+
+        sendBeforeChange.set(true);
+
+        long leaveVer = crd.cluster().topologyVersion() + 1;
+
+        stopGrid(LEAVING);
+
+        assertTrue("Node 1 didn't change a lost partition", 
waitForCondition(() -> !sendBeforeChange.get(), WAIT));
+
+        assertTrue("Node 1's map wasn't held", sndSpi.waitForBlocked(1, WAIT));
+
+        assertTrue(waitForCondition(() -> exchangeFinished(crd, leaveVer), 
WAIT));
+
+        GridDhtPartitionTopology crdTop = 
crd.cachex(CACHE).context().topology();
+
+        UUID sndId = grid(STALE_MAP_SENDER).localNode().id();
+
+        long seq = crdTop.partitionMap(false).get(sndId).updateSequence();
+
+        sndSpi.stopBlock();
+
+        assertTrue("The coordinator didn't take node 1's held map", 
waitForCondition(
+            () -> crdTop.partitionMap(false).get(sndId).updateSequence() > 
seq, WAIT));
+
+        checkNodes(crd, grid(OBSERVER), grid(CLIENT));
+    }
+
+    /**
+     * Checks that the partition maps of the coordinator, the observer and the 
client match the local states of the
+     * nodes after node 1 sends its map before it gets the full message.
+     * <p>
+     * When node 1's last RENTING partition is evicted, the map changes and 
node 1 schedules a resend. Node 1 doesn't
+     * know its lost partitions until it gets the full message, so the resent 
map doesn't have them. Its version is
+     * newer than the one the coordinator has, so the coordinator takes it. 
The test:
+     * <ol>
+     *     <li>holds the eviction of one partition that node 1 gives to the 
observer;</li>
+     *     <li>stops node 2 and holds the coordinator's full message to node 
1;</li>
+     *     <li>lets the eviction finish once the coordinator has finished the 
exchange;</li>
+     *     <li>lets the full message go once the coordinator has taken node 
1's resent map.</li>
+     * </ol>
+     *
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testStaleMapBeforeFullMessage() throws Exception {
+        holdEviction.set(true);
+
+        IgniteEx crd = startNodes();
+
+        awaitPartitionMapExchange();
+
+        assertTrue("Node 1 didn't start an eviction", evictionHeld.await(WAIT, 
MILLISECONDS));
+
+        IgniteEx snd = grid(STALE_MAP_SENDER);
+
+        GridDhtPartitionTopology sndTop = 
snd.cachex(CACHE).context().topology();
+
+        // Wait until only the held eviction is left: the last eviction 
schedules the resend.
+        assertTrue(waitForCondition(() -> sndTop.localPartitions().stream()
+            .filter(p -> p.state() == RENTING).count() == 1, WAIT));
+
+        UUID sndId = snd.localNode().id();
+
+        TestRecordingCommunicationSpi crdSpi = 
TestRecordingCommunicationSpi.spi(crd);
+
+        crdSpi.blockMessages((node, msg) -> node.id().equals(sndId)
+            && msg instanceof GridDhtPartitionsFullMessage
+            && ((GridDhtPartitionsFullMessage)msg).exchangeId() != null);
+
+        long leaveVer = crd.cluster().topologyVersion() + 1;
+
+        stopGrid(LEAVING);
+
+        assertTrue("The coordinator didn't send the full message", 
crdSpi.waitForBlocked(1, WAIT));
+
+        assertTrue(waitForCondition(() -> exchangeFinished(crd, leaveVer), 
WAIT));
+
+        GridDhtPartitionTopology crdTop = 
crd.cachex(CACHE).context().topology();
+
+        long seq = crdTop.partitionMap(false).get(sndId).updateSequence();
+
+        evictionResume.countDown();
+
+        assertTrue("The coordinator didn't take node 1's resent map", 
waitForCondition(
+            () -> crdTop.partitionMap(false).get(sndId).updateSequence() > 
seq, WAIT));
+
+        crdSpi.stopBlock();
+
+        checkNodes(crd, grid(OBSERVER), grid(CLIENT));
+    }
+
+    /**
+     * Checks that the coordinator sends its partition map again after it owns 
the lost partitions assigned to it.
+     * <p>
+     * The coordinator creates these partitions as MOVING, sends the full 
message, and only then owns them. When its
+     * last RENTING partition is evicted, the map changes and the coordinator 
schedules a resend. If the resend fires
+     * before the coordinator owns the partitions, it carries them as MOVING. 
Its version is newer than the full
+     * message's, so node 1 takes it. Node 1 sees the partitions OWNING only 
once the coordinator sends its map after
+     * owning them.
+     * <p>
+     * The test:
+     * <ol>
+     *     <li>holds the eviction of one partition that the coordinator gave 
to node 1;</li>
+     *     <li>stops node 2 and stalls the coordinator right after it sends 
the full message;</li>
+     *     <li>lets the eviction finish once node 1 has finished the 
exchange;</li>
+     *     <li>lets the coordinator go on once node 1 has taken the resent 
map.</li>
+     * </ol>
+     *
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testStaleCoordinatorMapAfterEviction() throws Exception {
+        crdNewPrimary = true;
+
+        IgniteEx crd = startGrid(0, partitionHooksResolver());
+
+        // Hold the eviction of one partition that node 1 takes over, as if 
the partition were large.
+        holdEviction.set(true);
+
+        IgniteEx other = startGrid(1);
+
+        IgniteEx client = startClientGrid(CLIENT);
+
+        awaitPartitionMapExchange();
+
+        assertTrue("The coordinator didn't start an eviction", 
evictionHeld.await(WAIT, MILLISECONDS));
+
+        startGrid(LEAVING);
+
+        awaitPartitionMapExchange();
+
+        GridDhtPartitionTopology crdTop = 
crd.cachex(CACHE).context().topology();
+
+        // Wait until only the held eviction is left: the last eviction 
schedules the resend,
+        // and no copy of node 2's partitions may stay on the coordinator.
+        assertTrue(waitForCondition(() -> crdTop.localPartitions().stream()
+            .filter(p -> p.state() == RENTING).count() == 1, WAIT));
+
+        UUID crdId = crd.localNode().id();
+
+        stallAfterFullMsg.set(true);
+
+        long leaveVer = crd.cluster().topologyVersion() + 1;
+
+        stopGrid(LEAVING);
+
+        assertTrue("The coordinator didn't send the full message", 
crdStalled.await(WAIT, MILLISECONDS));
+
+        assertTrue(waitForCondition(() -> exchangeFinished(other, leaveVer), 
WAIT));
+
+        GridDhtPartitionTopology otherTop = 
other.cachex(CACHE).context().topology();
+
+        long seq = otherTop.partitionMap(false).get(crdId).updateSequence();
+
+        evictionResume.countDown();
+
+        assertTrue("Node 1 didn't take the coordinator's resent map", 
waitForCondition(
+            () -> otherTop.partitionMap(false).get(crdId).updateSequence() > 
seq, WAIT));
+
+        crdResume.countDown();
+
+        assertTrue(waitForCondition(() -> exchangeFinished(crd, leaveVer), 
WAIT));
+
+        checkNodes(other, client);
+    }

Review Comment:
   This case covers the resend after markLost() in update(): without it the 
coordinator sees node 5's lost partitions as MOVING. If the SQL subclass stays, 
it has to skip this case too.
   ```suggestion
       }
   
       /**
        * Checks that the partition maps of the coordinator, the observer and 
the client match the local states of the
        * nodes after node 5 joins while partitions are lost under the 
READ_WRITE_SAFE policy. Node 5 marks its copies of
        * the lost partitions LOST when it applies the coordinator's full 
message.
        *
        * @throws Exception If failed.
        */
       @Test
       public void testJoinWhileLost() throws Exception {
           plc = READ_WRITE_SAFE;
   
           IgniteEx crd = startNodes();
   
           awaitPartitionMapExchange(true, true, null);
   
           long leaveVer = crd.cluster().topologyVersion() + 1;
   
           stopGrid(LEAVING);
   
           for (Ignite g : G.allGrids())
               assertTrue(waitForCondition(() -> exchangeFinished((IgniteEx)g, 
leaveVer), WAIT));
   
           IgniteEx joining = startGrid(JOINING);
   
           for (Ignite g : G.allGrids())
               assertTrue(waitForCondition(() -> exchangeFinished((IgniteEx)g, 
leaveVer + 1), WAIT));
   
           assertTrue("Node 5 didn't mark a partition LOST", 
joining.cachex(CACHE).context().topology()
               .localPartitions().stream().anyMatch(part -> part.state() == 
LOST));
   
           checkNodes(crd, grid(OBSERVER), grid(CLIENT));
       }
   ```



##########
modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/topology/GridDhtPartitionTopologyImpl.java:
##########
@@ -1616,14 +1619,18 @@ private boolean 
shouldOverridePartitionMap(GridDhtPartitionMap currentMap, GridD
                         this.lostParts = new HashSet<>(lostParts);
 
                         if (exchFut != null && !exchFut.activateCluster()) {
+                            boolean ownerReports =
+                                
ctx.kernalContext().rollingUpgrade().features().isActive(PART_STATE_FROM_OWNER_FEATURE);
+
                             for (Integer part : lostParts) {
                                 GridDhtLocalPartition locPart = 
localPartition(part);
 
                                 // EVICTED partitions should not be marked 
directly as LOST, or
                                 // part.clearFuture lifecycle will be broken 
after resetting.
                                 // New partition should be created instead.
                                 if (locPart != null && locPart.state() != 
EVICTED) {
-                                    locPart.markLost();
+                                    if (locPart.markLost() && ownerReports)
+                                        changed = true;

Review Comment:
   My earlier suggestion here was wrong: a node that joins while partitions are 
lost marks them LOST here, and without this resend the other nodes see them 
MOVING, on master too. Please keep the resend without the feature check and add 
the test suggested in CachePartitionLossStaleMapTest.
   ```suggestion
                               for (Integer part : lostParts) {
                                   GridDhtLocalPartition locPart = 
localPartition(part);
   
                                   // EVICTED partitions should not be marked 
directly as LOST, or
                                   // part.clearFuture lifecycle will be broken 
after resetting.
                                   // New partition should be created instead.
                                   if (locPart != null && locPart.state() != 
EVICTED) {
                                       if (locPart.markLost())
                                           changed = true;
   ```



##########
modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/topology/GridDhtPartitionTopologyImpl.java:
##########
@@ -2110,15 +2125,24 @@ private void ownOrphans() {
                 GridDhtLocalPartition locPart = localPartition(p);
 
                 if (locPart != null && locPart.state() != EVICTED && 
locPart.state() != LOST) {
-                    locPart.own();
+                    if (locPart.own()) {
+                        changed = true;
+
+                        if (ownerReports)
+                            updateLocal(p, OWNING, 
updateSeq.incrementAndGet(), readyTopVer);
+                    }

Review Comment:
   As in detectLostPartitions, the feature only has to stop the writes into the 
other nodes' rows. Please update the local row either way.
   ```suggestion
                       if (locPart.own()) {
                           changed = true;
   
                           updateLocal(p, OWNING, updateSeq.incrementAndGet(), 
readyTopVer);
                       }
   ```



##########
modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/PartitionStateFromOwnerRollingUpgradeTest.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.internal.processors.cache.distributed;
+
+import java.util.List;
+import java.util.UUID;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.TestRecordingCommunicationSpi;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleMessage;
+import 
org.apache.ignite.internal.processors.rollingupgrade.AbstractRollingUpgradeTest;
+import org.apache.ignite.internal.util.typedef.G;
+import org.apache.ignite.plugin.extensions.communication.Message;
+import org.junit.Test;
+
+import static org.apache.ignite.cache.PartitionLossPolicy.IGNORE;
+import static 
org.apache.ignite.internal.processors.cache.distributed.CachePartitionLossStaleMapTest.exchangeFinished;
+import static 
org.apache.ignite.internal.processors.cache.distributed.CachePartitionLossStaleMapTest.mismatches;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPreloader.DFLT_PRELOAD_RESEND_TIMEOUT;
+import static org.apache.ignite.testframework.GridTestUtils.waitForCondition;
+
+/**
+ * Checks that until {@code PART_STATE_FROM_OWNER_FEATURE} is active the nodes 
handle lost partitions as the previous
+ * version does: the other nodes write the new owners' state into their 
partition maps themselves. Once the feature is
+ * active, they take it from the owners' maps.
+ * <p>
+ * In both parts a server leaves with the only copies of some partitions under 
the IGNORE policy, while the maps that
+ * the other servers send outside an exchange are held, so the coordinator 
sees only the state it wrote itself. The
+ * coordinator and the client watch the new owners' partitions. The client 
hasn't started the cache, so it keeps the
+ * cache's partition map in a client topology.
+ */
+public class PartitionStateFromOwnerRollingUpgradeTest extends 
AbstractRollingUpgradeTest {
+    /** */
+    private static final String CACHE = "cache";
+
+    /** */
+    private static final int PARTS = 64;
+
+    /** Version without {@code PART_STATE_FROM_OWNER_FEATURE}. */
+    private static final String OLD_VER = "2.18.0";
+
+    /** Index of the client node, as started by {@link #startCluster(String)}. 
*/
+    private static final int CLIENT = 2;
+
+    /** Index of the server that leaves. */
+    private static final int LEAVING = 3;
+
+    /** Time to wait for the partition maps to match, in milliseconds. */
+    private static final long WAIT = 30_000;
+
+    /**
+     * Before the upgrade the coordinator and the client see the new owners 
right after the exchange, with the owners'
+     * maps held. Once all nodes are upgraded and the version is finalized, 
the feature is active, and they see the new
+     * owners only after the maps arrive. On activation a server resends its 
maps, and a client doesn't.

Review Comment:
   No resend on activation without the listener.
   ```suggestion
        * owners only after the maps arrive.
   ```



##########
modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CachePartitionLossStaleMapTest.java:
##########
@@ -0,0 +1,600 @@
+/*
+ * 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;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteException;
+import org.apache.ignite.cache.PartitionLossPolicy;
+import org.apache.ignite.cache.affinity.AffinityFunction;
+import org.apache.ignite.cache.affinity.AffinityFunctionContext;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.NodeStoppingException;
+import org.apache.ignite.internal.TestRecordingCommunicationSpi;
+import org.apache.ignite.internal.managers.communication.GridIoMessage;
+import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
+import org.apache.ignite.internal.processors.cache.IgniteInternalCache;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionMap;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleMessage;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.EvictionContext;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtLocalPartition;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionTopology;
+import 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionTopologyImpl;
+import org.apache.ignite.internal.processors.resource.DependencyResolver;
+import org.apache.ignite.internal.util.typedef.G;
+import org.apache.ignite.internal.util.typedef.internal.CU;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.lang.IgniteInClosure;
+import org.apache.ignite.plugin.extensions.communication.Message;
+import org.apache.ignite.spi.IgniteSpiException;
+import org.apache.ignite.testframework.TestDependencyResolver;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.junit.Test;
+
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.apache.ignite.cache.PartitionLossPolicy.IGNORE;
+import static org.apache.ignite.cache.PartitionLossPolicy.READ_WRITE_SAFE;
+import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.EVICTED;

Review Comment:
   For testJoinWhileLost below.
   ```suggestion
   import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.EVICTED;
   import static 
org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState.LOST;
   ```



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to