[ignite] branch master updated: IGNITE-11579 Add new commands to deal with garbage in partitions which left after cache destroy in shared cache groups

[ir...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

irakov pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git


The following commit(s) were added to refs/heads/master by this push:
     new dd4fa9c  IGNITE-11579 Add new commands to deal with garbage in partitions which left after cache destroy in shared cache groups
dd4fa9c is described below

commit dd4fa9c31d865591d7e683de1e39412535b540d3
Author: EdShangGG <es...@gridgain.com>
AuthorDate: Thu Apr 25 21:34:26 2019 +0300

    IGNITE-11579 Add new commands to deal with garbage in partitions which left after cache destroy in shared cache groups
    
    Signed-off-by: Ivan Rakov <ir...@apache.org>
---
 .../org/apache/ignite/internal/IgniteFeatures.java |   7 +-
 .../internal/commandline/CommandHandler.java       | 145 +++++++--
 .../internal/commandline/cache/CacheArguments.java |  34 +++
 .../internal/commandline/cache/CacheCommand.java   |  38 ++-
 .../cache/argument/FindAndDeleteGarbageArg.java    |  50 ++++
 .../cache/persistence/GridCacheOffheapManager.java |  30 ++
 .../processors/cache/persistence/IndexStorage.java |  16 +
 .../cache/persistence/IndexStorageImpl.java        |  31 +-
 .../processors/cache/tree/CacheDataTree.java       |   7 +-
 .../processors/query/GridQueryIndexing.java        |  25 ++
 .../internal/visor/VisorDataTransferObject.java    |   3 +
 ...orFindAndDeleteGarbageInPersistenceClosure.java | 332 +++++++++++++++++++++
 ...FindAndDeleteGarbageInPersistenceJobResult.java |  83 ++++++
 ...VisorFindAndDeleteGarbageInPersistenceTask.java | 121 ++++++++
 ...orFindAndDeleteGarbageInPersistenceTaskArg.java | 101 +++++++
 ...indAndDeleteGarbageInPersistenceTaskResult.java |  95 ++++++
 .../internal/visor/tx/FetchNearXidVersionTask.java |  11 +
 .../main/resources/META-INF/classnames.properties  | 324 ++++++++++++++------
 .../internal/commandline/CommandArgFactory.java    |   4 +
 .../commandline/CommandHandlerParsingTest.java     | 131 +++++++-
 .../IgniteClientCacheInitializationFailTest.java   |  10 +
 .../testframework/junits/GridAbstractTest.java     |   2 +-
 .../apache/ignite/util/GridCommandHandlerTest.java | 114 ++++---
 .../processors/query/h2/IgniteH2Indexing.java      |  80 +++++
 .../ignite/client/IgniteBinaryQueryTest.java       |   4 -
 .../db/IgniteCacheGroupsWithRestartsTest.java      | 313 +++++++++++++++++++
 .../query/h2/GridIndexFullRebuildTest.java         |   2 +-
 .../IgnitePdsWithIndexingCoreTestSuite.java        |   5 +-
 28 files changed, 1945 insertions(+), 173 deletions(-)

diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteFeatures.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteFeatures.java
index f1ac68e..d8277ab 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteFeatures.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteFeatures.java
@@ -54,9 +54,12 @@ public enum IgniteFeatures {
      */
     TRANSACTION_OWNER_THREAD_DUMP_PROVIDING(6),
 
-
     /** Displaying versbose transaction information: --info option of --tx control script command. */
-    TX_INFO_COMMAND(7);
+    TX_INFO_COMMAND(7),
+
+    /** Command which allow to detect and cleanup garbage which could left after destroying caches in shared groups */
+    FIND_AND_DELETE_GARBAGE_COMMAND(8);
+
 
     /**
      * Unique feature identifier.
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/commandline/CommandHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/commandline/CommandHandler.java
index 8f0ec3d..d049d48 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/commandline/CommandHandler.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/commandline/CommandHandler.java
@@ -64,6 +64,7 @@ import org.apache.ignite.internal.commandline.baseline.BaselineCommand;
 import org.apache.ignite.internal.commandline.cache.CacheArguments;
 import org.apache.ignite.internal.commandline.cache.CacheCommand;
 import org.apache.ignite.internal.commandline.cache.argument.DistributionCommandArg;
+import org.apache.ignite.internal.commandline.cache.argument.FindAndDeleteGarbageArg;
 import org.apache.ignite.internal.commandline.cache.argument.IdleVerifyCommandArg;
 import org.apache.ignite.internal.commandline.cache.argument.ListCommandArg;
 import org.apache.ignite.internal.commandline.cache.argument.ValidateIndexesCommandArg;
@@ -100,6 +101,10 @@ import org.apache.ignite.internal.visor.cache.VisorCacheEvictionConfiguration;
 import org.apache.ignite.internal.visor.cache.VisorCacheNearConfiguration;
 import org.apache.ignite.internal.visor.cache.VisorCacheRebalanceConfiguration;
 import org.apache.ignite.internal.visor.cache.VisorCacheStoreConfiguration;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceJobResult;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTask;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTaskArg;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTaskResult;
 import org.apache.ignite.internal.visor.misc.VisorClusterNode;
 import org.apache.ignite.internal.visor.misc.VisorWalTask;
 import org.apache.ignite.internal.visor.misc.VisorWalTaskArg;
@@ -164,6 +169,7 @@ import static org.apache.ignite.internal.commandline.OutputFormat.SINGLE_LINE;
 import static org.apache.ignite.internal.commandline.baseline.BaselineCommand.of;
 import static org.apache.ignite.internal.commandline.cache.CacheCommand.CONTENTION;
 import static org.apache.ignite.internal.commandline.cache.CacheCommand.DISTRIBUTION;
+import static org.apache.ignite.internal.commandline.cache.CacheCommand.FIND_AND_DELETE_GARBAGE;
 import static org.apache.ignite.internal.commandline.cache.CacheCommand.HELP;
 import static org.apache.ignite.internal.commandline.cache.CacheCommand.IDLE_VERIFY;
 import static org.apache.ignite.internal.commandline.cache.CacheCommand.LIST;
@@ -814,7 +820,7 @@ public class CommandHandler {
      * @param client Client.
      * @param cacheArgs Cache args.
      */
-    private void cache(GridClient client, CacheArguments cacheArgs) throws Throwable {
+    private Object cache(GridClient client, CacheArguments cacheArgs) throws Throwable {
         switch (cacheArgs.command()) {
             case HELP:
                 printCacheHelp();
@@ -846,11 +852,16 @@ public class CommandHandler {
 
                 break;
 
+            case FIND_AND_DELETE_GARBAGE:
+                return findAndDeleteGarbage(client, cacheArgs);
+
             default:
                 cacheView(client, cacheArgs);
 
                 break;
         }
+
+        return null;
     }
 
     /** */
@@ -873,6 +884,7 @@ public class CommandHandler {
         usageCache(VALIDATE_INDEXES, op(CACHES), OP_NODE_ID, op(or(CHECK_FIRST + " N", CHECK_THROUGH + " K")));
         usageCache(DISTRIBUTION, or(NODE_ID, NULL), op(CACHES), op(USER_ATTRIBUTES, "attrName1,...,attrNameN"));
         usageCache(RESET_LOST_PARTITIONS, CACHES);
+        usageCache(FIND_AND_DELETE_GARBAGE, op(GROUPS), OP_NODE_ID, op(FindAndDeleteGarbageArg.DELETE));
         nl();
     }
 
@@ -920,21 +932,7 @@ public class CommandHandler {
         VisorValidateIndexesTaskResult taskRes = executeTaskByNameOnNode(
             client, VALIDATE_INDEXES_TASK, taskArg, null);
 
-        boolean errors = false;
-
-        if (!F.isEmpty(taskRes.exceptions())) {
-            errors = true;
-
-            log("Index validation failed on nodes:");
-
-            for (Map.Entry<UUID, Exception> e : taskRes.exceptions().entrySet()) {
-                log(i("Node ID: " + e.getKey()));
-
-                log(i("Exception message:"));
-                log(i(e.getValue().getMessage(), 2));
-                nl();
-            }
-        }
+        boolean errors = printErrors(taskRes.exceptions(), "Index validation failed on nodes:");
 
         for (Map.Entry<UUID, VisorValidateIndexesJobResult> nodeEntry : taskRes.results().entrySet()) {
             if (!nodeEntry.getValue().hasIssues())
@@ -1039,6 +1037,79 @@ public class CommandHandler {
      * @param client Client.
      * @param cacheArgs Cache args.
      */
+    private VisorFindAndDeleteGarbageInPersistenceTaskResult findAndDeleteGarbage(
+        GridClient client,
+        CacheArguments cacheArgs
+    ) throws GridClientException {
+        checkFeatureSupportedByCluster(client, IgniteFeatures.FIND_AND_DELETE_GARBAGE_COMMAND, false);
+
+        VisorFindAndDeleteGarbageInPersistenceTaskArg taskArg = new VisorFindAndDeleteGarbageInPersistenceTaskArg(
+            cacheArgs.groups(),
+            cacheArgs.delete(),
+            cacheArgs.nodeId() != null ? Collections.singleton(cacheArgs.nodeId()) : null
+        );
+
+        VisorFindAndDeleteGarbageInPersistenceTaskResult taskRes = executeTask(
+            client, VisorFindAndDeleteGarbageInPersistenceTask.class, taskArg);
+
+        printErrors(taskRes.exceptions(), "Scanning for garbage failed on nodes:");
+
+        for (Map.Entry<UUID, VisorFindAndDeleteGarbageInPersistenceJobResult> nodeEntry : taskRes.result().entrySet()) {
+            if (!nodeEntry.getValue().hasGarbage()) {
+                log("Node "+ nodeEntry.getKey() + " - garbage not found.");
+
+                continue;
+            }
+
+            log("Garbage found on node " + nodeEntry.getKey() + ":");
+
+            VisorFindAndDeleteGarbageInPersistenceJobResult value = nodeEntry.getValue();
+
+            Map<Integer, Map<Integer, Long>> grpPartErrorsCount = value.checkResult();
+
+            if (!grpPartErrorsCount.isEmpty()) {
+                for (Map.Entry<Integer, Map<Integer, Long>> entry : grpPartErrorsCount.entrySet()) {
+                    for (Map.Entry<Integer, Long> e : entry.getValue().entrySet()) {
+                        log(i("Group=" + entry.getKey() +
+                            ", partition=" + e.getKey() +
+                            ", count of keys=" + e.getValue()));
+                    }
+                }
+            }
+
+            nl();
+        }
+
+        return taskRes;
+    }
+
+    /**
+     * @param exceptions Exception per node.
+     * @param msg Message to print before errors if at least one presented.
+     * @return True if found any error.
+     */
+    private boolean printErrors(Map<UUID, Exception> exceptions, String msg) {
+        if (!F.isEmpty(exceptions)) {
+            log(msg);
+
+            for (Map.Entry<UUID, Exception> e : exceptions.entrySet()) {
+                log(i("Node ID: " + e.getKey()));
+
+                log(i("Exception message:"));
+                log(i(e.getValue().getMessage(), 2));
+                nl();
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @param client Client.
+     * @param cacheArgs Cache args.
+     */
     private void legacyCacheIdleVerify(GridClient client, CacheArguments cacheArgs) throws GridClientException {
         VisorIdleVerifyTaskResult res = executeTask(
             client,
@@ -1951,6 +2022,9 @@ public class CommandHandler {
             case RESET_LOST_PARTITIONS:
                 return "Reset the state of lost partitions for the specified caches.";
 
+            case FIND_AND_DELETE_GARBAGE:
+                return "Find and optionally delete garbage from shared cache groups which could be left after cache destroy.";
+
             default:
                 throw new IllegalArgumentException("Unknown command: " + cmd);
         }
@@ -1982,6 +2056,11 @@ public class CommandHandler {
                 map.put(CHECK_CRC.toString(), "check the CRC-sum of pages stored on disk before verifying data consistency in partitions between primary and backup nodes.");
 
                 break;
+
+            case FIND_AND_DELETE_GARBAGE:
+                map.put(FindAndDeleteGarbageArg.DELETE.toString(), "remove found garbage or not");
+
+                break;
         }
         return map;
     }
@@ -2454,7 +2533,7 @@ public class CommandHandler {
 
                 break;
 
-            case VALIDATE_INDEXES:
+            case VALIDATE_INDEXES: {
                 int argsCnt = 0;
 
                 while (hasNextSubArg() && argsCnt++ < 4) {
@@ -2503,6 +2582,7 @@ public class CommandHandler {
                 }
 
                 break;
+            }
 
             case DISTRIBUTION:
                 String nodeIdStr = nextArg("Node id expected or null");
@@ -2584,6 +2664,35 @@ public class CommandHandler {
 
                 break;
 
+            case FIND_AND_DELETE_GARBAGE: {
+                int argsCnt = 0;
+
+                while (hasNextSubArg() && argsCnt++ < 3) {
+                    String nextArg = nextArg("");
+
+                    FindAndDeleteGarbageArg arg = CommandArgUtils.of(nextArg, FindAndDeleteGarbageArg.class);
+
+                    if (arg == FindAndDeleteGarbageArg.DELETE) {
+                        cacheArgs.delete(true);
+
+                        continue;
+                    }
+
+                    try {
+                        cacheArgs.nodeId(UUID.fromString(nextArg));
+
+                        continue;
+                    }
+                    catch (IllegalArgumentException ignored) {
+                        //No-op.
+                    }
+
+                    cacheArgs.groups(parseCacheNames(nextArg));
+                }
+
+                break;
+            }
+
             default:
                 throw new IllegalArgumentException("Unknown --cache subcommand " + cmd);
         }
@@ -3191,7 +3300,7 @@ public class CommandHandler {
                             break;
 
                         case CACHE:
-                            cache(client, args.cacheArgs());
+                            lastOperationRes = cache(client, args.cacheArgs());
 
                             break;
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheArguments.java b/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheArguments.java
index 93bbf76..cd29474 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheArguments.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheArguments.java
@@ -33,6 +33,9 @@ public class CacheArguments {
     /** Caches. */
     private Set<String> caches;
 
+    /** Caches. */
+    private Set<String> groups;
+
     /** Exclude caches or groups. */
     private Set<String> excludeCaches;
 
@@ -81,6 +84,9 @@ public class CacheArguments {
     /** Check CRC sum on idle verify. */
     private boolean idleCheckCrc;
 
+    /** Delete garbage flag. */
+    private boolean delete;
+
     /**
      * @return Gets filter of caches, which will by checked.
      */
@@ -324,4 +330,32 @@ public class CacheArguments {
     public void idleCheckCrc(boolean idleCheckCrc) {
         this.idleCheckCrc = idleCheckCrc;
     }
+
+    /**
+     * @return Set of groups to run operation on.
+     */
+    public Set<String> groups() {
+        return groups;
+    }
+
+    /**
+     * @param groups Set of groups to run operation on.
+     */
+    public void groups(Set<String> groups) {
+        this.groups = groups;
+    }
+
+    /**
+     * @return Delete found garbage or not.
+     */
+    public boolean delete() {
+        return delete;
+    }
+
+    /**
+     * @param delete Delete found garbage or not.
+     */
+    public void delete(boolean delete) {
+        this.delete = delete;
+    }
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheCommand.java b/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheCommand.java
index 63a55d8..2ccaecb 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheCommand.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/CacheCommand.java
@@ -1,19 +1,19 @@
 /*
-* 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.
-*/
+ * 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.commandline.cache;
 
@@ -56,7 +56,13 @@ public enum CacheCommand {
     /**
      * Reset lost partitions
      */
-    RESET_LOST_PARTITIONS("reset_lost_partitions");
+    RESET_LOST_PARTITIONS("reset_lost_partitions"),
+
+    /**
+     * Find and remove garbage.
+     */
+    FIND_AND_DELETE_GARBAGE("find_garbage");
+
 
     /** Enumerated values. */
     private static final CacheCommand[] VALS = values();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/argument/FindAndDeleteGarbageArg.java b/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/argument/FindAndDeleteGarbageArg.java
new file mode 100644
index 0000000..fa6ed58
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/commandline/cache/argument/FindAndDeleteGarbageArg.java
@@ -0,0 +1,50 @@
+/*
+ *
+ *  * 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.commandline.cache.argument;
+
+import org.apache.ignite.internal.commandline.argument.CommandArg;
+
+/**
+ * List of extra arguments.
+ */
+public enum FindAndDeleteGarbageArg implements CommandArg {
+    DELETE("--delete");
+
+    /** Argument name. */
+    private final String name;
+
+    /**
+     * @param name Argument name.
+     */
+    FindAndDeleteGarbageArg(String name) {
+        this.name = name;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String argName() {
+        return name;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return name;
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java
index 2107d6c..4f02dcf 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java
@@ -1055,6 +1055,36 @@ public class GridCacheOffheapManager extends IgniteCacheOffheapManagerImpl imple
     }
 
     /**
+     * @param cacheId Which was stopped, but its data still presented.
+     * @throws IgniteCheckedException If failed.
+     */
+    public void findAndCleanupLostIndexesForStoppedCache(int cacheId) throws IgniteCheckedException {
+        for (String name : indexStorage.getIndexNames()) {
+            if (indexStorage.nameIsAssosiatedWithCache(name, cacheId)) {
+                ctx.database().checkpointReadLock();
+
+                try {
+                    RootPage page = indexStorage.allocateIndex(name);
+
+                    ctx.kernalContext().query().getIndexing().destroyOrphanIndex(
+                        page,
+                        name,
+                        grp.groupId(),
+                        grp.dataRegion().pageMemory(), globalRemoveId(),
+                        reuseListForIndex(name),
+                        grp.mvccEnabled()
+                    );
+
+                    indexStorage.dropIndex(name);
+                }
+                finally {
+                    ctx.database().checkpointReadUnlock();
+                }
+            }
+        }
+    }
+
+    /**
      *
      */
     private static class WALHistoricalIterator implements IgniteHistoricalIterator {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorage.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorage.java
index 295ff00..f9c6031 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorage.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorage.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.processors.cache.persistence;
 
+import java.util.Collection;
 import org.apache.ignite.IgniteCheckedException;
 
 /**
@@ -70,4 +71,19 @@ public interface IndexStorage {
      * @throws IgniteCheckedException  If failed.
      */
     public void destroy() throws IgniteCheckedException;
+
+    /**
+     * @return Index names of all indexes which this storage keeps.
+     *
+     * @throws IgniteCheckedException  If failed.
+     */
+    public Collection<String> getIndexNames() throws IgniteCheckedException;
+
+    /**
+     *
+     * @param idxName Index name to check.
+     * @param cacheId Cache id to check.
+     * @return True if the given idxName could be assosiated with the given cacheId (existing is not checked).
+     */
+    boolean nameIsAssosiatedWithCache(String idxName, int cacheId);
 }
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorageImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorageImpl.java
index b29553c..07a1270 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorageImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IndexStorageImpl.java
@@ -18,6 +18,8 @@
 package org.apache.ignite.internal.processors.cache.persistence;
 
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.concurrent.atomic.AtomicLong;
 import org.apache.ignite.IgniteCheckedException;
 import org.apache.ignite.IgniteException;
@@ -33,6 +35,7 @@ import org.apache.ignite.internal.processors.cache.persistence.tree.io.IOVersion
 import org.apache.ignite.internal.processors.cache.persistence.tree.reuse.ReuseList;
 import org.apache.ignite.internal.processors.cache.persistence.tree.util.PageHandler;
 import org.apache.ignite.internal.processors.failure.FailureProcessor;
+import org.apache.ignite.internal.util.lang.GridCursor;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.jetbrains.annotations.Nullable;
 
@@ -171,6 +174,29 @@ public class IndexStorageImpl implements IndexStorage {
         metaTree.destroy();
     }
 
+    /** {@inheritDoc} */
+    @Override public Collection<String> getIndexNames() throws IgniteCheckedException {
+        assert metaTree != null;
+        
+        GridCursor<IndexItem> cursor = metaTree.find(null, null);
+
+        ArrayList<String> names = new ArrayList<>((int)metaTree.size());
+
+        while (cursor.next()) {
+            IndexItem item = cursor.get();
+            
+            if (item != null)
+                names.add(new String(item.idxName));
+        }
+        
+        return names;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean nameIsAssosiatedWithCache(String idxName, int cacheId) {
+        return !grpShared || idxName.startsWith(Integer.toString(cacheId));
+    }
+
     /**
      * Mask cache index name.
      *
@@ -178,10 +204,7 @@ public class IndexStorageImpl implements IndexStorage {
      * @return Masked name.
      */
     private String maskCacheIndexName(Integer cacheId, String idxName, int segment) {
-        if (grpShared)
-            idxName = Integer.toString(cacheId) + "_" + idxName;
-
-        return idxName + "%" + segment;
+        return (grpShared ? (Integer.toString(cacheId) + "_") : "") + idxName + "%" + segment;
     }
 
     /**
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataTree.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataTree.java
index b3c1c69..73a6fbb 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataTree.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataTree.java
@@ -145,8 +145,11 @@ public class CacheDataTree extends BPlusTree<CacheSearchRow, CacheDataRow> {
         Object x
     ) throws IgniteCheckedException {
         // If there is a group of caches, lower and upper bounds will not be null here.
-        if (lower == null && upper == null && grp.persistenceEnabled() && dataPageScanEnabled.get() &&
-            (c == null || c instanceof MvccDataPageClosure))
+        if (lower == null
+                && upper == null
+                && grp.persistenceEnabled()
+                && dataPageScanEnabled.get()
+                && (c == null || c instanceof MvccDataPageClosure))
             return scanDataPages(asRowData(x), (MvccDataPageClosure)c);
 
         lastFindWithDataPageScan = FALSE;
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryIndexing.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryIndexing.java
index be775bf..dc2bc0f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryIndexing.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/GridQueryIndexing.java
@@ -29,13 +29,17 @@ import org.apache.ignite.cache.query.SqlQuery;
 import org.apache.ignite.internal.GridKernalContext;
 import org.apache.ignite.internal.IgniteInternalFuture;
 import org.apache.ignite.internal.managers.IgniteMBeansManager;
+import org.apache.ignite.internal.pagemem.PageMemory;
 import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
 import org.apache.ignite.internal.processors.cache.GridCacheContext;
 import org.apache.ignite.internal.processors.cache.GridCacheContextInfo;
 import org.apache.ignite.internal.processors.cache.mvcc.MvccSnapshot;
 import org.apache.ignite.internal.processors.cache.persistence.CacheDataRow;
+import org.apache.ignite.internal.processors.cache.persistence.RootPage;
+import org.apache.ignite.internal.processors.cache.persistence.tree.reuse.ReuseList;
 import org.apache.ignite.internal.processors.odbc.jdbc.JdbcParameterMeta;
 import org.apache.ignite.internal.processors.query.schema.SchemaIndexCacheVisitor;
+import org.apache.ignite.internal.util.GridAtomicLong;
 import org.apache.ignite.internal.util.GridSpinBusyLock;
 import org.apache.ignite.internal.util.lang.GridCloseableIterator;
 import org.apache.ignite.lang.IgniteBiTuple;
@@ -208,6 +212,27 @@ public interface GridQueryIndexing {
     public void unregisterCache(GridCacheContextInfo cacheInfo, boolean rmvIdx) throws IgniteCheckedException;
 
     /**
+     * Destroy founded index which belongs to stopped cache.
+     *
+     * @param page Root page.
+     * @param indexName Index name.
+     * @param grpId Group id which contains garbage.
+     * @param pageMemory Page memory to work with.
+     * @param removeId Global remove id.
+     * @param reuseList Reuse list where free pages should be stored.
+     * @param mvccEnabled Is mvcc enabled for group or not.
+     * @throws IgniteCheckedException If failed.
+     */
+    public void destroyOrphanIndex(
+        RootPage page,
+        String indexName,
+        int grpId,
+        PageMemory pageMemory,
+        final GridAtomicLong removeId,
+        final ReuseList reuseList,
+        boolean mvccEnabled) throws IgniteCheckedException;
+
+    /**
      *
      * @param cctx Cache context.
      * @param ids Involved cache ids.
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/VisorDataTransferObject.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/VisorDataTransferObject.java
index 6fd51cd..22863e4 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/visor/VisorDataTransferObject.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/VisorDataTransferObject.java
@@ -59,6 +59,9 @@ public abstract class VisorDataTransferObject implements Externalizable {
      * @return List based on passed collection.
      */
     @Nullable protected static <T> List<T> toList(Collection<T> col) {
+        if(col instanceof List)
+            return (List<T>)col;
+
         if (col != null)
             return new ArrayList<>(col);
 
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceClosure.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceClosure.java
new file mode 100644
index 0000000..37af676
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceClosure.java
@@ -0,0 +1,332 @@
+/*
+* 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.visor.cache;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.IgniteException;
+import org.apache.ignite.IgniteInterruptedException;
+import org.apache.ignite.IgniteLogger;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.processors.cache.CacheGroupContext;
+import org.apache.ignite.internal.processors.cache.GridCacheContext;
+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.persistence.CacheDataRow;
+import org.apache.ignite.internal.processors.cache.persistence.GridCacheOffheapManager;
+import org.apache.ignite.internal.util.lang.GridIterator;
+import org.apache.ignite.internal.util.typedef.F;
+import org.apache.ignite.internal.util.typedef.T2;
+import org.apache.ignite.internal.util.typedef.internal.CU;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.lang.IgniteCallable;
+import org.apache.ignite.resources.IgniteInstanceResource;
+import org.apache.ignite.resources.LoggerResource;
+
+/**
+ * Class contains logic of finding data of already destroyed caches in running cache groups.
+ *
+ * Also, could cleanup this garbage in cache partitions and indexes.
+ */
+public class VisorFindAndDeleteGarbageInPersistenceClosure implements IgniteCallable<VisorFindAndDeleteGarbageInPersistenceJobResult> {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Ignite. */
+    @IgniteInstanceResource
+    private transient IgniteEx ignite;
+
+    /** Injected logger. */
+    @LoggerResource
+    private IgniteLogger log;
+
+    /** Cache group names. */
+    private Set<String> grpNames;
+
+    /** Remove garbage. */
+    private final boolean deleteGarbage;
+
+    /** Counter of processed partitions. */
+    private final AtomicInteger processedPartitions = new AtomicInteger(0);
+
+    /** Total partitions. */
+    private volatile int totalPartitions;
+
+    /** Last progress print timestamp. */
+    private final AtomicLong lastProgressPrintTs = new AtomicLong(0);
+
+    /** Calculation executor. */
+    private volatile ExecutorService calcExecutor;
+
+    /**
+     * @param grpNames Cache group names.
+     * @param deleteGarbage Clean up garbage from partitions.
+     */
+    public VisorFindAndDeleteGarbageInPersistenceClosure(Set<String> grpNames, boolean deleteGarbage) {
+        this.grpNames = grpNames;
+        this.deleteGarbage = deleteGarbage;
+    }
+
+    /** {@inheritDoc} */
+    @Override public VisorFindAndDeleteGarbageInPersistenceJobResult call() throws Exception {
+        calcExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+
+        try {
+            return call0();
+        }
+        finally {
+            calcExecutor.shutdown();
+        }
+    }
+
+    /**
+     *
+     */
+    private VisorFindAndDeleteGarbageInPersistenceJobResult call0() {
+        Set<Integer> grpIds = calcCacheGroupIds();
+
+        List<T2<CacheGroupContext, GridDhtLocalPartition>> partArgs = calcListOfPartitions(grpIds);
+
+        totalPartitions = partArgs.size();
+
+        List<Future<Map<Integer, Map<Integer, Long>>>> procPartFutures = new ArrayList<>();
+
+        for (final T2<CacheGroupContext, GridDhtLocalPartition> t2 : partArgs)
+            procPartFutures.add(calcExecutor.submit(new Callable<Map<Integer, Map<Integer, Long>>>() {
+                @Override public Map<Integer, Map<Integer, Long>> call() throws Exception {
+                    return processPartition(t2.get1(), t2.get2());
+                }
+            }));
+
+
+        Map<Integer, Map<Integer, Long>> grpIdToPartIdToGarbageCount = new HashMap<>();
+
+        int curPart = 0;
+
+        try {
+            for (; curPart < procPartFutures.size(); curPart++) {
+                Future<Map<Integer, Map<Integer, Long>>> fut = procPartFutures.get(curPart);
+
+                Map<Integer, Map<Integer, Long>> partRes = fut.get();
+
+                for (Map.Entry<Integer, Map<Integer, Long>> e : partRes.entrySet()) {
+                    Map<Integer, Long> map = grpIdToPartIdToGarbageCount.computeIfAbsent(e.getKey(), (x) -> new HashMap<>());
+
+                    for (Map.Entry<Integer, Long> entry : e.getValue().entrySet())
+                        map.compute(entry.getKey(), (k, v) -> (v == null ? 0 : v) + entry.getValue());
+                }
+            }
+
+            if (deleteGarbage)
+                cleanup(grpIdToPartIdToGarbageCount);
+
+            log.warning("VisorFindAndDeleteGarbageInPersistenceClosure finished: processed " + totalPartitions + " partitions.");
+        }
+        catch (InterruptedException | ExecutionException | IgniteCheckedException e) {
+            for (int j = curPart; j < procPartFutures.size(); j++)
+                procPartFutures.get(j).cancel(false);
+
+            throw unwrapFutureException(e);
+        }
+
+        return new VisorFindAndDeleteGarbageInPersistenceJobResult(grpIdToPartIdToGarbageCount);
+    }
+
+    /**
+     * By calling this method we would delete found garbarge in partitions and would try to
+     * cleanup indexes.
+     *
+     * @param grpIdToPartIdToGarbageCount GrpId -&gt; PartId -&gt; Garbage count.
+     */
+    private void cleanup(Map<Integer, Map<Integer, Long>> grpIdToPartIdToGarbageCount) throws IgniteCheckedException {
+        for (Map.Entry<Integer, Map<Integer, Long>> e : grpIdToPartIdToGarbageCount.entrySet()) {
+            int grpId = e.getKey();
+
+            CacheGroupContext groupContext = ignite.context().cache().cacheGroup(grpId);
+
+            assert groupContext != null;
+
+            for (Integer cacheId : e.getValue().keySet()) {
+                groupContext.offheap().stopCache(cacheId, true);
+
+                ((GridCacheOffheapManager)
+                    groupContext.offheap()).findAndCleanupLostIndexesForStoppedCache(cacheId);
+            }
+        }
+    }
+
+   /**
+    * @param grpIds Group ids to generate list of partitions for.
+    */
+   private List<T2<CacheGroupContext, GridDhtLocalPartition>> calcListOfPartitions(Set<Integer> grpIds) {
+        List<T2<CacheGroupContext, GridDhtLocalPartition>> partArgs = new ArrayList<>();
+
+        for (Integer grpId : grpIds) {
+            CacheGroupContext grpCtx = ignite.context().cache().cacheGroup(grpId);
+
+            List<GridDhtLocalPartition> parts = grpCtx.topology().localPartitions();
+
+            for (GridDhtLocalPartition part : parts)
+                partArgs.add(new T2<>(grpCtx, part));
+        }
+
+        // To decrease contention on same group.
+        Collections.shuffle(partArgs);
+        return partArgs;
+    }
+
+    /**
+     * @return Set of cache group ids to scan for garbage on.
+     */
+    private Set<Integer> calcCacheGroupIds() {
+        Set<Integer> grpIds = new HashSet<>();
+
+        Set<String> missingCacheGroups = new HashSet<>();
+
+        if (!F.isEmpty(grpNames)) {
+            for (String grpName : grpNames) {
+                CacheGroupContext groupContext = ignite.context().cache().cacheGroup(CU.cacheId(grpName));
+
+                if (groupContext == null) {
+                    missingCacheGroups.add(grpName);
+
+                    continue;
+                }
+
+                if (groupContext.sharedGroup())
+                    grpIds.add(groupContext.groupId());
+                else
+                    log.warning("Group[name=" + grpName + "] is not shared one, it couldn't contain garbage from destroyed caches.");
+            }
+
+            if (!missingCacheGroups.isEmpty()) {
+                StringBuilder strBuilder = new StringBuilder("The following cache groups do not exist: ");
+
+                for (String name : missingCacheGroups)
+                    strBuilder.append(name).append(", ");
+
+                strBuilder.delete(strBuilder.length() - 2, strBuilder.length());
+
+                throw new IgniteException(strBuilder.toString());
+            }
+        }
+        else {
+            Collection<CacheGroupContext> groups = ignite.context().cache().cacheGroups();
+
+            for (CacheGroupContext grp : groups) {
+                if (!grp.systemCache() && !grp.isLocal())
+                    grpIds.add(grp.groupId());
+            }
+        }
+
+        return grpIds;
+    }
+
+    /**
+     * @param grpCtx Group context.
+     * @param part Local partition.
+     */
+    private Map<Integer, Map<Integer, Long>> processPartition(
+        CacheGroupContext grpCtx,
+        GridDhtLocalPartition part
+    ) {
+        if (!part.reserve())
+            return Collections.emptyMap();
+
+        Map<Integer, Map<Integer, Long>> stoppedCachesForGrpId = new HashMap<>();
+
+        try {
+            if (part.state() != GridDhtPartitionState.OWNING)
+                return Collections.emptyMap();
+
+            GridIterator<CacheDataRow> it = grpCtx.offheap().partitionIterator(part.id());
+
+            while (it.hasNextX()) {
+                CacheDataRow row = it.nextX();
+
+                if (row.cacheId() == 0)
+                    break;
+
+                int cacheId = row.cacheId();
+
+                GridCacheContext cacheCtx = grpCtx.shared().cacheContext(row.cacheId());
+
+                if (cacheCtx == null)
+                    stoppedCachesForGrpId
+                        .computeIfAbsent(grpCtx.groupId(), (x) -> new HashMap<>())
+                        .compute(cacheId, (x, y) -> y == null? 1 : y + 1);
+            }
+        }
+        catch (IgniteCheckedException e) {
+            U.error(log, "Failed to process partition [grpId=" + grpCtx.groupId() +
+                ", partId=" + part.id() + "]", e);
+
+            return Collections.emptyMap();
+        }
+        finally {
+            part.release();
+        }
+
+        processedPartitions.incrementAndGet();
+
+        printProgressIfNeeded();
+
+        return stoppedCachesForGrpId;
+    }
+
+    /**
+     *
+     */
+    private void printProgressIfNeeded() {
+        long curTs = U.currentTimeMillis();
+        long lastTs = lastProgressPrintTs.get();
+
+        if (curTs - lastTs >= 60_000 && lastProgressPrintTs.compareAndSet(lastTs, curTs))
+            log.warning("Current progress of VisorFindAndDeleteGarbageInPersistenceClosure: checked "
+                + processedPartitions.get() + " partitions out of " + totalPartitions);
+    }
+
+    /**
+     * @param e Future result exception.
+     * @return Unwrapped exception.
+     */
+    private IgniteException unwrapFutureException(Exception e) {
+        assert e instanceof InterruptedException || e instanceof ExecutionException : "Expecting either InterruptedException " +
+                "or ExecutionException";
+
+        if (e instanceof InterruptedException)
+            return new IgniteInterruptedException((InterruptedException)e);
+        else if (e.getCause() instanceof IgniteException)
+            return  (IgniteException)e.getCause();
+        else
+            return new IgniteException(e.getCause());
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceJobResult.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceJobResult.java
new file mode 100644
index 0000000..1c557cd
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceJobResult.java
@@ -0,0 +1,83 @@
+/*
+* 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.visor.cache;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Map;
+import org.apache.ignite.internal.dto.IgniteDataTransferObject;
+import org.apache.ignite.internal.util.tostring.GridToStringInclude;
+import org.apache.ignite.internal.util.typedef.internal.S;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Result of job work which is sent between nodes.
+ */
+public class VisorFindAndDeleteGarbageInPersistenceJobResult extends IgniteDataTransferObject {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Results of indexes validation from node. */
+    @GridToStringInclude
+    private Map<Integer, Map<Integer, Long>> result;
+
+
+    /**
+     * @param result Results with founded garbage (GroupId -> (CacheId, Count of keys)).
+     */
+    public VisorFindAndDeleteGarbageInPersistenceJobResult(@NotNull Map<Integer, Map<Integer, Long>> result) {
+        this.result = result;
+    }
+
+    /**
+     * For externalization only.
+     */
+    public VisorFindAndDeleteGarbageInPersistenceJobResult() {
+    }
+
+    /**
+     * @return Results of indexes validation from node.
+     */
+    public Map<Integer, Map<Integer, Long>> checkResult() {
+        return result;
+    }
+
+    /**
+     * @return {@code true} If any indexes issues found on node, otherwise returns {@code false}.
+     */
+    public boolean hasGarbage() {
+        return result != null && !result.isEmpty();
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void writeExternalData(ObjectOutput out) throws IOException {
+        U.writeMap(out, result);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void readExternalData(byte protoVer, ObjectInput in) throws IOException, ClassNotFoundException {
+        result = U.readMap(in);
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(VisorFindAndDeleteGarbageInPersistenceJobResult.class, this);
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTask.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTask.java
new file mode 100644
index 0000000..ad167e3
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTask.java
@@ -0,0 +1,121 @@
+/*
+* 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.visor.cache;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ignite.IgniteException;
+import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.compute.ComputeJobResult;
+import org.apache.ignite.internal.processors.task.GridInternal;
+import org.apache.ignite.internal.util.typedef.internal.S;
+import org.apache.ignite.internal.visor.VisorJob;
+import org.apache.ignite.internal.visor.VisorMultiNodeTask;
+import org.apache.ignite.internal.visor.VisorTaskArgument;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Compute task which are part of 'find and delete garbage' functionality.
+ */
+@GridInternal
+public class VisorFindAndDeleteGarbageInPersistenceTask extends VisorMultiNodeTask<VisorFindAndDeleteGarbageInPersistenceTaskArg,
+    VisorFindAndDeleteGarbageInPersistenceTaskResult, VisorFindAndDeleteGarbageInPersistenceJobResult> {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** {@inheritDoc} */
+    @Nullable @Override protected VisorFindAndDeleteGarbageInPersistenceTaskResult reduce0(List<ComputeJobResult> list) throws IgniteException {
+        Map<UUID, Exception> exceptions = new HashMap<>();
+        Map<UUID, VisorFindAndDeleteGarbageInPersistenceJobResult> jobResults = new HashMap<>();
+
+        for (ComputeJobResult res : list) {
+            if (res.getException() != null)
+                exceptions.put(res.getNode().id(), res.getException());
+            else
+                jobResults.put(res.getNode().id(), res.getData());
+        }
+
+        return new VisorFindAndDeleteGarbageInPersistenceTaskResult(jobResults, exceptions);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected VisorJob<VisorFindAndDeleteGarbageInPersistenceTaskArg, VisorFindAndDeleteGarbageInPersistenceJobResult> job(VisorFindAndDeleteGarbageInPersistenceTaskArg arg) {
+        return new FindAndDeleteGarbageInPersistenceJob(arg, debug);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected Collection<UUID> jobNodes(VisorTaskArgument<VisorFindAndDeleteGarbageInPersistenceTaskArg> arg) {
+        Collection<ClusterNode> srvNodes = ignite.cluster().forServers().nodes();
+        Collection<UUID> ret = new ArrayList<>(srvNodes.size());
+
+        Set<UUID> nodeIds = arg.getArgument().getNodes();
+
+        if (nodeIds == null) {
+            for (ClusterNode node : srvNodes)
+                ret.add(node.id());
+        }
+        else {
+            for (ClusterNode node : srvNodes) {
+                if (nodeIds.contains(node.id()))
+                    ret.add(node.id());
+            }
+        }
+
+        return ret;
+    }
+
+    /**
+     *
+     */
+    private static class FindAndDeleteGarbageInPersistenceJob extends VisorJob<VisorFindAndDeleteGarbageInPersistenceTaskArg, VisorFindAndDeleteGarbageInPersistenceJobResult> {
+        /** */
+        private static final long serialVersionUID = 0L;
+
+        /**
+         * @param arg Argument.
+         * @param debug Debug.
+         */
+        protected FindAndDeleteGarbageInPersistenceJob(@Nullable VisorFindAndDeleteGarbageInPersistenceTaskArg arg, boolean debug) {
+            super(arg, debug);
+        }
+
+        /** {@inheritDoc} */
+        @Override protected VisorFindAndDeleteGarbageInPersistenceJobResult run(@Nullable VisorFindAndDeleteGarbageInPersistenceTaskArg arg) throws IgniteException {
+            try {
+                VisorFindAndDeleteGarbageInPersistenceClosure closure = new VisorFindAndDeleteGarbageInPersistenceClosure(arg.getGrpNames(), arg.deleteFoundGarbage());
+
+                ignite.context().resource().injectGeneric(closure);
+
+                return closure.call();
+            }
+            catch (Exception e) {
+                throw new IgniteException(e);
+            }
+        }
+
+        /** {@inheritDoc} */
+        @Override public String toString() {
+            return S.toString(FindAndDeleteGarbageInPersistenceJob.class, this);
+        }
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTaskArg.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTaskArg.java
new file mode 100644
index 0000000..0fad3cf
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTaskArg.java
@@ -0,0 +1,101 @@
+/*
+ * 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.visor.cache;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ignite.internal.dto.IgniteDataTransferObject;
+import org.apache.ignite.internal.util.typedef.internal.S;
+import org.apache.ignite.internal.util.typedef.internal.U;
+
+/**
+ * {@link VisorFindAndDeleteGarbageInPersistenceTask} arguments.
+ */
+public class VisorFindAndDeleteGarbageInPersistenceTaskArg extends IgniteDataTransferObject {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Group names. */
+    private Set<String> grpNames;
+
+    /** Would be used  */
+    private boolean deleteFoundGarbage;
+
+    /** Nodes on which task will run. */
+    private Set<UUID> nodes;
+
+    /**
+     * Default constructor.
+     */
+    public VisorFindAndDeleteGarbageInPersistenceTaskArg() {
+        // No-op.
+    }
+
+    /**
+     * @param grpNames Cache group names.
+     */
+    public VisorFindAndDeleteGarbageInPersistenceTaskArg(Set<String> grpNames, boolean deleteFoundGarbage, Set<UUID> nodes) {
+        this.grpNames = grpNames;
+        this.deleteFoundGarbage = deleteFoundGarbage;
+        this.nodes = nodes;
+    }
+
+    /**
+     * @return Caches.
+     */
+    public Set<String> getGrpNames() {
+        return grpNames;
+    }
+
+    /**
+     * @return Nodes on which task will run. If {@code null}, task will run on all server nodes.
+     */
+    public Set<UUID> getNodes() {
+        return nodes;
+    }
+
+    /**
+     * @return True if need to delete garbage as it found.
+     */
+    public boolean deleteFoundGarbage() {
+        return deleteFoundGarbage;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void writeExternalData(ObjectOutput out) throws IOException {
+        U.writeCollection(out, grpNames);
+        out.writeBoolean(deleteFoundGarbage);
+        U.writeCollection(out, nodes);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void readExternalData(byte protoVer, ObjectInput in) throws IOException, ClassNotFoundException {
+        grpNames = U.readSet(in);
+        deleteFoundGarbage = in.readBoolean();
+
+        nodes = U.readSet(in);
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(VisorFindAndDeleteGarbageInPersistenceTaskArg.class, this);
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTaskResult.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTaskResult.java
new file mode 100644
index 0000000..e4e1411
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorFindAndDeleteGarbageInPersistenceTaskResult.java
@@ -0,0 +1,95 @@
+/*
+* 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.visor.cache;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.ignite.internal.dto.IgniteDataTransferObject;
+import org.apache.ignite.internal.util.tostring.GridToStringInclude;
+import org.apache.ignite.internal.util.typedef.internal.S;
+import org.apache.ignite.internal.util.typedef.internal.U;
+
+/**
+ * Result of running {@link VisorFindAndDeleteGarbageInPersistenceTask} which would contain result
+ * from all participating nodes.
+ */
+public class VisorFindAndDeleteGarbageInPersistenceTaskResult extends IgniteDataTransferObject {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Results of indexes validation from node. */
+    @GridToStringInclude
+    private Map<UUID, VisorFindAndDeleteGarbageInPersistenceJobResult> result;
+
+    /** Exceptions while indexes validation from node. */
+    @GridToStringInclude
+    private Map<UUID, Exception> exceptions;
+
+    /**
+     *
+     */
+    public VisorFindAndDeleteGarbageInPersistenceTaskResult() {
+    }
+
+    /**
+     * For externalization only.
+     * @param jobResults Per node job result.
+     * @param exceptions Per node execution problems.
+     */
+    public VisorFindAndDeleteGarbageInPersistenceTaskResult(
+        Map<UUID, VisorFindAndDeleteGarbageInPersistenceJobResult> jobResults,
+        Map<UUID, Exception> exceptions
+    ) {
+        this.result = jobResults;
+        this.exceptions = exceptions;
+    }
+
+    /**
+     * @return Results of indexes validation from node.
+     */
+    public Map<UUID, VisorFindAndDeleteGarbageInPersistenceJobResult> result() {
+        return result;
+    }
+
+    /**
+     * @return Exception of execution on nodes.
+     */
+    public Map<UUID, Exception> exceptions() {
+        return exceptions;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void writeExternalData(ObjectOutput out) throws IOException {
+        U.writeMap(out, result);
+        U.writeMap(out, exceptions);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void readExternalData(byte protoVer, ObjectInput in) throws IOException, ClassNotFoundException {
+        result = U.readMap(in);
+        exceptions = U.readMap(in);
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(VisorFindAndDeleteGarbageInPersistenceTaskResult.class, this);
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/tx/FetchNearXidVersionTask.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/tx/FetchNearXidVersionTask.java
index c2b3e2b..0bfa5f7 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/visor/tx/FetchNearXidVersionTask.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/tx/FetchNearXidVersionTask.java
@@ -18,7 +18,10 @@ package org.apache.ignite.internal.visor.tx;
 
 import java.util.Collection;
 import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
 import org.apache.ignite.IgniteException;
+import org.apache.ignite.cluster.ClusterNode;
 import org.apache.ignite.compute.ComputeJobResult;
 import org.apache.ignite.internal.processors.cache.transactions.IgniteInternalTx;
 import org.apache.ignite.internal.processors.cache.transactions.IgniteTxManager;
@@ -26,6 +29,7 @@ import org.apache.ignite.internal.processors.cache.version.GridCacheVersion;
 import org.apache.ignite.internal.processors.task.GridInternal;
 import org.apache.ignite.internal.visor.VisorJob;
 import org.apache.ignite.internal.visor.VisorMultiNodeTask;
+import org.apache.ignite.internal.visor.VisorTaskArgument;
 import org.jetbrains.annotations.Nullable;
 
 /**
@@ -83,4 +87,11 @@ public class FetchNearXidVersionTask extends VisorMultiNodeTask<TxVerboseId, Gri
             return null;
         }
     }
+
+    /** {@inheritDoc} */
+    @Override protected Collection<UUID> jobNodes(VisorTaskArgument<TxVerboseId> arg) {
+        return ignite.cluster().nodes().stream()
+            .map(ClusterNode::id)
+            .collect(Collectors.toList());
+    }
 }
diff --git a/modules/core/src/main/resources/META-INF/classnames.properties b/modules/core/src/main/resources/META-INF/classnames.properties
index 49f3843..8dc231c 100644
--- a/modules/core/src/main/resources/META-INF/classnames.properties
+++ b/modules/core/src/main/resources/META-INF/classnames.properties
@@ -51,6 +51,7 @@ org.apache.ignite.cache.affinity.AffinityFunction
 org.apache.ignite.cache.affinity.AffinityKey
 org.apache.ignite.cache.affinity.AffinityKeyMapper
 org.apache.ignite.cache.affinity.AffinityUuid
+org.apache.ignite.cache.affinity.rendezvous.ClusterNodeAttributeAffinityBackupFilter
 org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction
 org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction$HashComparator
 org.apache.ignite.cache.eviction.AbstractEvictionPolicy
@@ -73,6 +74,7 @@ org.apache.ignite.cache.query.ContinuousQuery
 org.apache.ignite.cache.query.ContinuousQueryWithTransformer
 org.apache.ignite.cache.query.Query
 org.apache.ignite.cache.query.QueryCancelledException
+org.apache.ignite.cache.query.QueryRetryException
 org.apache.ignite.cache.query.ScanQuery
 org.apache.ignite.cache.query.SpiQuery
 org.apache.ignite.cache.query.SqlFieldsQuery
@@ -153,6 +155,7 @@ org.apache.ignite.configuration.DataPageEvictionMode
 org.apache.ignite.configuration.DataRegionConfiguration
 org.apache.ignite.configuration.DataStorageConfiguration
 org.apache.ignite.configuration.DeploymentMode
+org.apache.ignite.configuration.DiskPageCompression
 org.apache.ignite.configuration.IgniteReflectionFactory
 org.apache.ignite.configuration.MemoryConfiguration
 org.apache.ignite.configuration.MemoryPolicyConfiguration
@@ -166,6 +169,7 @@ org.apache.ignite.events.CacheQueryExecutedEvent
 org.apache.ignite.events.CacheQueryReadEvent
 org.apache.ignite.events.CacheRebalancingEvent
 org.apache.ignite.events.CheckpointEvent
+org.apache.ignite.events.ClusterActivationEvent
 org.apache.ignite.events.DeploymentEvent
 org.apache.ignite.events.DiscoveryEvent
 org.apache.ignite.events.Event
@@ -249,6 +253,7 @@ org.apache.ignite.internal.IgniteDiagnosticPrepareContext$1
 org.apache.ignite.internal.IgniteDiagnosticPrepareContext$CompoundInfoClosure
 org.apache.ignite.internal.IgniteEventsImpl
 org.apache.ignite.internal.IgniteEventsImpl$1
+org.apache.ignite.internal.IgniteFeatures
 org.apache.ignite.internal.IgniteFutureCancelledCheckedException
 org.apache.ignite.internal.IgniteFutureTimeoutCheckedException
 org.apache.ignite.internal.IgniteInterruptedCheckedException
@@ -262,10 +267,10 @@ org.apache.ignite.internal.IgniteServicesImpl
 org.apache.ignite.internal.IgnitionEx$IgniteNamedInstance$2
 org.apache.ignite.internal.IgnitionEx$IgniteNamedInstance$3
 org.apache.ignite.internal.IgnitionEx$IgniteNamedInstance$4
+org.apache.ignite.internal.IgnitionEx$IgniteNamedInstance$5
 org.apache.ignite.internal.NodeStoppingException
 org.apache.ignite.internal.SecurityCredentialsAttrFilterPredicate
 org.apache.ignite.internal.TransactionMetricsMxBeanImpl
-org.apache.ignite.internal.TransactionsMXBeanImpl$1
 org.apache.ignite.internal.UnregisteredBinaryTypeException
 org.apache.ignite.internal.UnregisteredClassException
 org.apache.ignite.internal.binary.BinaryEnumObjectImpl
@@ -330,32 +335,38 @@ org.apache.ignite.internal.cluster.IgniteKillTask$IgniteKillJob
 org.apache.ignite.internal.cluster.NodeOrderComparator
 org.apache.ignite.internal.cluster.NodeOrderLegacyComparator
 org.apache.ignite.internal.commandline.Command
-org.apache.ignite.internal.commandline.CommandHandler$1
-org.apache.ignite.internal.commandline.CommandHandler$2
+org.apache.ignite.internal.commandline.OutputFormat
+org.apache.ignite.internal.commandline.baseline.AutoAdjustCommandArg
+org.apache.ignite.internal.commandline.baseline.BaselineCommand
 org.apache.ignite.internal.commandline.cache.CacheCommand
+org.apache.ignite.internal.commandline.cache.argument.DistributionCommandArg
+org.apache.ignite.internal.commandline.cache.argument.FindAndDeleteGarbageArg
+org.apache.ignite.internal.commandline.cache.argument.IdleVerifyCommandArg
+org.apache.ignite.internal.commandline.cache.argument.ListCommandArg
+org.apache.ignite.internal.commandline.cache.argument.ValidateIndexesCommandArg
 org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionGroup
 org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionNode
 org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionPartition
-org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionTask$CacheDistributionJob
 org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionTask
+org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionTask$CacheDistributionJob
 org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionTaskArg
-org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionTaskResult$1
-org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionTaskResult$Row
 org.apache.ignite.internal.commandline.cache.distribution.CacheDistributionTaskResult
-org.apache.ignite.internal.commandline.cache.reset_lost_partitions.CacheResetLostPartitionsTaskResult
-org.apache.ignite.internal.commandline.cache.reset_lost_partitions.CacheResetLostPartitionsTask$CacheResetLostPartitionsJob
 org.apache.ignite.internal.commandline.cache.reset_lost_partitions.CacheResetLostPartitionsTask
+org.apache.ignite.internal.commandline.cache.reset_lost_partitions.CacheResetLostPartitionsTask$CacheResetLostPartitionsJob
 org.apache.ignite.internal.commandline.cache.reset_lost_partitions.CacheResetLostPartitionsTaskArg
+org.apache.ignite.internal.commandline.cache.reset_lost_partitions.CacheResetLostPartitionsTaskResult
 org.apache.ignite.internal.compute.ComputeTaskCancelledCheckedException
 org.apache.ignite.internal.compute.ComputeTaskTimeoutCheckedException
 org.apache.ignite.internal.direct.DirectMessageReader$1
 org.apache.ignite.internal.direct.DirectMessageWriter$1
+org.apache.ignite.internal.dto.IgniteDataTransferObject
 org.apache.ignite.internal.events.DiscoveryCustomEvent
 org.apache.ignite.internal.executor.GridExecutorService
 org.apache.ignite.internal.executor.GridExecutorService$1
 org.apache.ignite.internal.executor.GridExecutorService$TaskTerminateListener
 org.apache.ignite.internal.igfs.common.IgfsIpcCommand
 org.apache.ignite.internal.jdbc.thin.ConnectionPropertiesImpl
+org.apache.ignite.internal.jdbc.thin.ConnectionPropertiesImpl$1
 org.apache.ignite.internal.jdbc.thin.ConnectionPropertiesImpl$BooleanProperty
 org.apache.ignite.internal.jdbc.thin.ConnectionPropertiesImpl$ConnectionProperty
 org.apache.ignite.internal.jdbc.thin.ConnectionPropertiesImpl$IntegerProperty
@@ -374,7 +385,6 @@ org.apache.ignite.internal.jdbc2.JdbcQueryTaskV3
 org.apache.ignite.internal.managers.GridManagerAdapter$1$1
 org.apache.ignite.internal.managers.checkpoint.GridCheckpointManager$CheckpointSet
 org.apache.ignite.internal.managers.checkpoint.GridCheckpointRequest
-org.apache.ignite.internal.managers.communication.GridIoManager$1
 org.apache.ignite.internal.managers.communication.GridIoManager$ConcurrentHashMap0
 org.apache.ignite.internal.managers.communication.GridIoMessage
 org.apache.ignite.internal.managers.communication.GridIoUserMessage
@@ -396,6 +406,9 @@ org.apache.ignite.internal.managers.discovery.GridDiscoveryManager$6
 org.apache.ignite.internal.managers.discovery.GridDiscoveryManager$8
 org.apache.ignite.internal.managers.discovery.GridDiscoveryManager$9
 org.apache.ignite.internal.managers.discovery.GridLocalMetrics
+org.apache.ignite.internal.managers.encryption.GenerateEncryptionKeyRequest
+org.apache.ignite.internal.managers.encryption.GenerateEncryptionKeyResponse
+org.apache.ignite.internal.managers.encryption.GridEncryptionManager$NodeEncryptionKeys
 org.apache.ignite.internal.managers.eventstorage.GridEventStorageMessage
 org.apache.ignite.internal.managers.indexing.GridIndexingManager$1
 org.apache.ignite.internal.managers.loadbalancer.GridLoadBalancerAdapter
@@ -403,20 +416,22 @@ org.apache.ignite.internal.managers.loadbalancer.GridLoadBalancerManager$1
 org.apache.ignite.internal.marshaller.optimized.OptimizedFieldType
 org.apache.ignite.internal.mem.IgniteOutOfMemoryException
 org.apache.ignite.internal.pagemem.impl.PageMemoryNoStoreImpl$Segment
-org.apache.ignite.internal.processors.cache.persistence.StorageException
 org.apache.ignite.internal.pagemem.wal.WALIterator
 org.apache.ignite.internal.pagemem.wal.WALPointer
 org.apache.ignite.internal.pagemem.wal.record.ExchangeRecord$Type
+org.apache.ignite.internal.pagemem.wal.record.RolloverType
+org.apache.ignite.internal.pagemem.wal.record.WALRecord$RecordPurpose
 org.apache.ignite.internal.pagemem.wal.record.WALRecord$RecordType
 org.apache.ignite.internal.pagemem.wal.record.delta.DeltaApplicationException
 org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion
 org.apache.ignite.internal.processors.affinity.GridAffinityAssignment
+org.apache.ignite.internal.processors.affinity.GridAffinityAssignmentV2
 org.apache.ignite.internal.processors.affinity.GridAffinityMessage
+org.apache.ignite.internal.processors.affinity.GridAffinityProcessor$2
+org.apache.ignite.internal.processors.affinity.GridAffinityProcessor$AffinityFuture$1
 org.apache.ignite.internal.processors.affinity.GridAffinityUtils$AffinityJob
 org.apache.ignite.internal.processors.authentication.IgniteAccessControlException
-org.apache.ignite.internal.processors.authentication.IgniteAuthenticationProcessor$3
 org.apache.ignite.internal.processors.authentication.IgniteAuthenticationProcessor$InitialUsersData
-org.apache.ignite.internal.processors.authentication.IgniteAuthenticationProcessor$RefreshUsersStorageWorker$1
 org.apache.ignite.internal.processors.authentication.User
 org.apache.ignite.internal.processors.authentication.UserAcceptedMessage
 org.apache.ignite.internal.processors.authentication.UserAuthenticateRequestMessage
@@ -438,22 +453,20 @@ org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$14
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$15
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$16
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$17
+org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$17$1
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$18
-org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$18$1
-org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$18$2
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$19
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$2
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$20
-org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$21
-org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$22
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$4
-org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$5
+org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$6
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$7
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$8
 org.apache.ignite.internal.processors.cache.CacheAffinitySharedManager$9
 org.apache.ignite.internal.processors.cache.CacheClientReconnectDiscoveryData
 org.apache.ignite.internal.processors.cache.CacheClientReconnectDiscoveryData$CacheGroupInfo
 org.apache.ignite.internal.processors.cache.CacheClientReconnectDiscoveryData$CacheInfo
+org.apache.ignite.internal.processors.cache.CacheConfigurationEnrichment
 org.apache.ignite.internal.processors.cache.CacheData
 org.apache.ignite.internal.processors.cache.CacheDefaultBinaryAffinityKeyMapper
 org.apache.ignite.internal.processors.cache.CacheEntryImpl
@@ -467,7 +480,6 @@ org.apache.ignite.internal.processors.cache.CacheEntryPredicateNoValue
 org.apache.ignite.internal.processors.cache.CacheEntrySerializablePredicate
 org.apache.ignite.internal.processors.cache.CacheEvictionEntry
 org.apache.ignite.internal.processors.cache.CacheGroupContext$2
-org.apache.ignite.internal.processors.cache.CacheGroupContext$3
 org.apache.ignite.internal.processors.cache.CacheGroupData
 org.apache.ignite.internal.processors.cache.CacheInvalidStateException
 org.apache.ignite.internal.processors.cache.CacheInvokeDirectResult
@@ -502,6 +514,7 @@ org.apache.ignite.internal.processors.cache.DynamicCacheChangeRequest
 org.apache.ignite.internal.processors.cache.EntryProcessorResourceInjectorProxy
 org.apache.ignite.internal.processors.cache.ExchangeActions$1
 org.apache.ignite.internal.processors.cache.ExchangeActions$2
+org.apache.ignite.internal.processors.cache.FetchActiveTxOwnerTraceClosure
 org.apache.ignite.internal.processors.cache.GatewayProtectedCacheProxy
 org.apache.ignite.internal.processors.cache.GridCacheAdapter
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$10
@@ -521,14 +534,12 @@ org.apache.ignite.internal.processors.cache.GridCacheAdapter$3
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$30
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$32
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$4
+org.apache.ignite.internal.processors.cache.GridCacheAdapter$47
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$48
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$49
-org.apache.ignite.internal.processors.cache.GridCacheAdapter$50
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$51
+org.apache.ignite.internal.processors.cache.GridCacheAdapter$52
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$53
-org.apache.ignite.internal.processors.cache.GridCacheAdapter$54
-org.apache.ignite.internal.processors.cache.GridCacheAdapter$55
-org.apache.ignite.internal.processors.cache.GridCacheAdapter$56
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$6
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$8
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$AsyncOp$1
@@ -545,6 +556,7 @@ org.apache.ignite.internal.processors.cache.GridCacheAdapter$LoadCacheClosure
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$LoadCacheJob
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$LoadCacheJobV2
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$LoadKeysCallable
+org.apache.ignite.internal.processors.cache.GridCacheAdapter$PartitionPreloadJob
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$PartitionSizeLongJob
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$PartitionSizeLongTask
 org.apache.ignite.internal.processors.cache.GridCacheAdapter$SizeJob
@@ -585,13 +597,17 @@ org.apache.ignite.internal.processors.cache.GridCacheLoaderWriterStoreFactory
 org.apache.ignite.internal.processors.cache.GridCacheLockTimeoutException
 org.apache.ignite.internal.processors.cache.GridCacheLogger
 org.apache.ignite.internal.processors.cache.GridCacheMapEntry$1
+org.apache.ignite.internal.processors.cache.GridCacheMapEntry$MvccAcquireLockListener
+org.apache.ignite.internal.processors.cache.GridCacheMapEntry$MvccRemoveLockListener
+org.apache.ignite.internal.processors.cache.GridCacheMapEntry$MvccUpdateLockListener
 org.apache.ignite.internal.processors.cache.GridCacheMessage
 org.apache.ignite.internal.processors.cache.GridCacheMultiTxFuture$1
 org.apache.ignite.internal.processors.cache.GridCacheMvccCandidate
 org.apache.ignite.internal.processors.cache.GridCacheMvccCandidate$Mask
-org.apache.ignite.internal.processors.cache.GridCacheMvccManager$5
+org.apache.ignite.internal.processors.cache.GridCacheMvccEntryInfo
 org.apache.ignite.internal.processors.cache.GridCacheMvccManager$6
 org.apache.ignite.internal.processors.cache.GridCacheMvccManager$7
+org.apache.ignite.internal.processors.cache.GridCacheMvccManager$8
 org.apache.ignite.internal.processors.cache.GridCacheMvccManager$FinishLockFuture$1
 org.apache.ignite.internal.processors.cache.GridCacheOperation
 org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$2
@@ -599,7 +615,8 @@ org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$2$
 org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$3
 org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$4
 org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$5
-org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$6
+org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$7
+org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$9
 org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$ExchangeFutureSet
 org.apache.ignite.internal.processors.cache.GridCachePartitionExchangeManager$MessageHandler
 org.apache.ignite.internal.processors.cache.GridCacheProcessor$1
@@ -610,6 +627,8 @@ org.apache.ignite.internal.processors.cache.GridCacheProcessor$3
 org.apache.ignite.internal.processors.cache.GridCacheProcessor$4
 org.apache.ignite.internal.processors.cache.GridCacheProcessor$5
 org.apache.ignite.internal.processors.cache.GridCacheProcessor$6
+org.apache.ignite.internal.processors.cache.GridCacheProcessor$7
+org.apache.ignite.internal.processors.cache.GridCacheProcessor$7$1
 org.apache.ignite.internal.processors.cache.GridCacheProcessor$8
 org.apache.ignite.internal.processors.cache.GridCacheProcessor$9
 org.apache.ignite.internal.processors.cache.GridCacheProcessor$LocalAffinityFunction
@@ -632,7 +651,8 @@ org.apache.ignite.internal.processors.cache.GridCacheUtils$18
 org.apache.ignite.internal.processors.cache.GridCacheUtils$19
 org.apache.ignite.internal.processors.cache.GridCacheUtils$2
 org.apache.ignite.internal.processors.cache.GridCacheUtils$20
-org.apache.ignite.internal.processors.cache.GridCacheUtils$22
+org.apache.ignite.internal.processors.cache.GridCacheUtils$21
+org.apache.ignite.internal.processors.cache.GridCacheUtils$23
 org.apache.ignite.internal.processors.cache.GridCacheUtils$3
 org.apache.ignite.internal.processors.cache.GridCacheUtils$4
 org.apache.ignite.internal.processors.cache.GridCacheUtils$5
@@ -663,12 +683,12 @@ org.apache.ignite.internal.processors.cache.IgniteCacheProxyImpl$4
 org.apache.ignite.internal.processors.cache.IgniteCacheProxyImpl$6
 org.apache.ignite.internal.processors.cache.IgniteCacheProxyImpl$7
 org.apache.ignite.internal.processors.cache.IgniteCacheProxyImpl$8
-org.apache.ignite.internal.processors.cache.IgniteCacheProxyImpl$9
 org.apache.ignite.internal.processors.cache.IgniteRebalanceIterator
 org.apache.ignite.internal.processors.cache.KeyCacheObject
 org.apache.ignite.internal.processors.cache.KeyCacheObjectImpl
 org.apache.ignite.internal.processors.cache.QueryCursorImpl$State
 org.apache.ignite.internal.processors.cache.StoredCacheData
+org.apache.ignite.internal.processors.cache.TxOwnerDumpRequestAllowedSettingClosure
 org.apache.ignite.internal.processors.cache.TxTimeoutOnPartitionMapExchangeChangeMessage
 org.apache.ignite.internal.processors.cache.WalStateAbstractMessage
 org.apache.ignite.internal.processors.cache.WalStateAckMessage
@@ -680,7 +700,7 @@ org.apache.ignite.internal.processors.cache.affinity.GridCacheAffinityProxy
 org.apache.ignite.internal.processors.cache.binary.BinaryMetadataHolder
 org.apache.ignite.internal.processors.cache.binary.BinaryMetadataKey
 org.apache.ignite.internal.processors.cache.binary.BinaryMetadataTransport$2
-org.apache.ignite.internal.processors.cache.binary.CacheObjectBinaryProcessorImpl$3
+org.apache.ignite.internal.processors.cache.binary.CacheObjectBinaryProcessorImpl$2
 org.apache.ignite.internal.processors.cache.binary.MetadataRequestMessage
 org.apache.ignite.internal.processors.cache.binary.MetadataResponseMessage
 org.apache.ignite.internal.processors.cache.binary.MetadataResponseMessage$ClientResponseStatus
@@ -714,6 +734,10 @@ org.apache.ignite.internal.processors.cache.distributed.GridDistributedTxPrepare
 org.apache.ignite.internal.processors.cache.distributed.GridDistributedTxRemoteAdapter
 org.apache.ignite.internal.processors.cache.distributed.GridDistributedUnlockRequest
 org.apache.ignite.internal.processors.cache.distributed.IgniteExternalizableExpiryPolicy
+org.apache.ignite.internal.processors.cache.distributed.dht.CacheDistributedGetFutureAdapter$1
+org.apache.ignite.internal.processors.cache.distributed.dht.CacheDistributedGetFutureAdapter$AbstractMiniFuture$1
+org.apache.ignite.internal.processors.cache.distributed.dht.CacheDistributedGetFutureAdapter$AbstractMiniFuture$2
+org.apache.ignite.internal.processors.cache.distributed.dht.CacheDistributedGetFutureAdapter$AbstractMiniFuture$2$1
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtAffinityAssignmentRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtAffinityAssignmentResponse
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtCache
@@ -732,15 +756,13 @@ org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtGetFuture$3
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtGetSingleFuture$1
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtGetSingleFuture$2
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtGetSingleFuture$3
-org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtInvalidPartitionException
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtLockFuture$1
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtLockFuture$2
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtLockFuture$3
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtLockFuture$4
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtLockRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtLockResponse
-org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtPartitionState
-org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtPartitionsReservation$1
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTopologyFutureAdapter$OperationType
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$1
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$10
@@ -748,7 +770,16 @@ org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactional
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$12
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$13
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$14
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$15
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$16
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$17
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$18
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$19
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$2
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$20
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$21
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$22
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$23
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$3
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$4
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$5
@@ -756,6 +787,8 @@ org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactional
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$7
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$8
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTransactionalCacheAdapter$9
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxAbstractEnlistFuture$1
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxAbstractEnlistFuture$2
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxFinishFuture$1
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxFinishRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxFinishResponse
@@ -773,18 +806,16 @@ org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxPrepareFutu
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxPrepareFuture$4
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxPrepareRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxPrepareResponse
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxQueryEnlistRequest
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxQueryEnlistResponse
+org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxQueryFirstEnlistRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTxRemote
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtUnlockRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtUnreservedPartitionException
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedGetFuture$1
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedGetFuture$2
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedGetFuture$MiniFuture$1
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedGetFuture$MiniFuture$2
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedGetFuture$MiniFuture$3
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedGetFuture$MiniFuture$3$1
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedSingleGetFuture$1
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedSingleGetFuture$2
-org.apache.ignite.internal.processors.cache.distributed.dht.GridPartitionedSingleGetFuture$3
+org.apache.ignite.internal.processors.cache.distributed.dht.GridInvokeValue
+org.apache.ignite.internal.processors.cache.distributed.dht.NearTxQueryEnlistResultHandler
+org.apache.ignite.internal.processors.cache.distributed.dht.NearTxResultHandler
+org.apache.ignite.internal.processors.cache.distributed.dht.PartitionUpdateCountersMessage
 org.apache.ignite.internal.processors.cache.distributed.dht.atomic.GridDhtAtomicAbstractUpdateFuture$1
 org.apache.ignite.internal.processors.cache.distributed.dht.atomic.GridDhtAtomicAbstractUpdateRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.atomic.GridDhtAtomicCache
@@ -845,18 +876,18 @@ org.apache.ignite.internal.processors.cache.distributed.dht.atomic.NearCacheUpda
 org.apache.ignite.internal.processors.cache.distributed.dht.atomic.UpdateErrors
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$1
+org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$10
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$2
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$3
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$4$1
-org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$6
+org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$5
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$7
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$8
+org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedCache$9
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedLockFuture$1
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedLockFuture$2
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedLockFuture$3
-org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedLockFuture$4
 org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedLockFuture$LockTimeoutObject$1
-org.apache.ignite.internal.processors.cache.distributed.dht.colocated.GridDhtColocatedLockFuture$MiniFuture$1
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CacheGroupAffinityMessage
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CachePartitionFullCountersMap
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CachePartitionPartialCountersMap
@@ -873,6 +904,7 @@ org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPar
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionFullMap
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionMap
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionSupplyMessage
+org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionSupplyMessageV2
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsAbstractMessage
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$2
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$3
@@ -881,11 +913,12 @@ org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPar
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$6
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$7
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$8
-org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$9
-org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$9$1$1
+org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$8$1$1
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$ExchangeLocalState
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture$ExchangeType
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage
+org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage$1
+org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage$2
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleMessage
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleRequest
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPreloader$1
@@ -899,6 +932,9 @@ org.apache.ignite.internal.processors.cache.distributed.dht.preloader.IgniteDhtP
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.IgniteHistoricalIterator
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.IgniteRebalanceIteratorImpl
 org.apache.ignite.internal.processors.cache.distributed.dht.preloader.latch.LatchAckMessage
+org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtInvalidPartitionException
+org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionState
+org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtPartitionsReservation$1
 org.apache.ignite.internal.processors.cache.distributed.near.CacheVersionedValue
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearAtomicCache
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearAtomicCache$1
@@ -906,12 +942,6 @@ org.apache.ignite.internal.processors.cache.distributed.near.GridNearCacheAdapte
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearCacheAdapter$2
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearCacheAdapter$3
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearCacheAdapter$EntrySet$1
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetFuture$1
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetFuture$2
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetFuture$MiniFuture$1
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetFuture$MiniFuture$2
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetFuture$MiniFuture$3
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetFuture$MiniFuture$3$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetRequest
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearGetResponse
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearLockFuture$1
@@ -924,7 +954,6 @@ org.apache.ignite.internal.processors.cache.distributed.near.GridNearLockRequest
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearLockResponse
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticSerializableTxPrepareFuture$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticSerializableTxPrepareFuture$2
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticSerializableTxPrepareFuture$3
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticSerializableTxPrepareFuture$ClientRemapFutureReducer
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticSerializableTxPrepareFuture$MiniFuture$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticSerializableTxPrepareFuture$MiniFuture$1$1
@@ -933,8 +962,6 @@ org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticT
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticTxPrepareFuture$3
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticTxPrepareFuture$4
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticTxPrepareFuture$5
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticTxPrepareFuture$MiniFuture$1
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearOptimisticTxPrepareFutureAdapter$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearPessimisticTxPrepareFuture$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearPessimisticTxPrepareFuture$2
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearSingleGetRequest
@@ -942,6 +969,11 @@ org.apache.ignite.internal.processors.cache.distributed.near.GridNearSingleGetRe
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTransactionalCache
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTransactionalCache$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTransactionalCache$2
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxAbstractEnlistFuture$1
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxEnlistFuture$1
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxEnlistFuture$2
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxEnlistRequest
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxEnlistResponse
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxFinishFuture$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxFinishFuture$2
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxFinishFuture$3
@@ -951,24 +983,30 @@ org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxFinishRes
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$10
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$11
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$12
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$13
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$14
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$15
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$16
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$17
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$18
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$19
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$2
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$20
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$21
-org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$21$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$22
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$23
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$24
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$25
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$26
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$27
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$27$1
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$28
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$29
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$3
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$30
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$31
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$32
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$4
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$5
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$6
@@ -979,6 +1017,14 @@ org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxLocal$Fin
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxPrepareFutureAdapter$1
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxPrepareRequest
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxPrepareResponse
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryEnlistFuture$1
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryEnlistFuture$2
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryEnlistRequest
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryEnlistResponse
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryResultsEnlistFuture$1
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryResultsEnlistFuture$2
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryResultsEnlistRequest
+org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxQueryResultsEnlistResponse
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxRemote
 org.apache.ignite.internal.processors.cache.distributed.near.GridNearUnlockRequest
 org.apache.ignite.internal.processors.cache.dr.GridCacheDrExpirationInfo
@@ -991,18 +1037,45 @@ org.apache.ignite.internal.processors.cache.local.atomic.GridLocalAtomicCache$4
 org.apache.ignite.internal.processors.cache.local.atomic.GridLocalAtomicCache$5
 org.apache.ignite.internal.processors.cache.local.atomic.GridLocalAtomicCache$8
 org.apache.ignite.internal.processors.cache.local.atomic.GridLocalAtomicCache$9
+org.apache.ignite.internal.processors.cache.mvcc.DeadlockProbe
+org.apache.ignite.internal.processors.cache.mvcc.MvccCoordinator
+org.apache.ignite.internal.processors.cache.mvcc.MvccProcessorImpl$2
+org.apache.ignite.internal.processors.cache.mvcc.MvccProcessorImpl$4
+org.apache.ignite.internal.processors.cache.mvcc.MvccProcessorImpl$4$1
+org.apache.ignite.internal.processors.cache.mvcc.MvccProcessorImpl$MvccMessageListener$1
+org.apache.ignite.internal.processors.cache.mvcc.MvccSnapshot
+org.apache.ignite.internal.processors.cache.mvcc.MvccSnapshotWithoutTxs
+org.apache.ignite.internal.processors.cache.mvcc.MvccVersionImpl
+org.apache.ignite.internal.processors.cache.mvcc.ProbedTx
+org.apache.ignite.internal.processors.cache.mvcc.VacuumMetricsReducer
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccAckRequestQueryCntr
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccAckRequestQueryId
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccAckRequestTx
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccAckRequestTxAndQueryCntr
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccAckRequestTxAndQueryId
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccActiveQueriesMessage
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccFutureResponse
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccMessage
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccQuerySnapshotRequest
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccRecoveryFinishedMessage
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccSnapshotResponse
+org.apache.ignite.internal.processors.cache.mvcc.msg.MvccTxSnapshotRequest
+org.apache.ignite.internal.processors.cache.mvcc.msg.PartitionCountersNeighborcastRequest
+org.apache.ignite.internal.processors.cache.mvcc.msg.PartitionCountersNeighborcastResponse
 org.apache.ignite.internal.processors.cache.persistence.CacheDataRowAdapter$RowData
-org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager$2
 org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager$4
-org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager$7
+org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager$8
+org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager$CheckpointReadLockTimeoutException
 org.apache.ignite.internal.processors.cache.persistence.GridCacheOffheapManager$WALHistoricalIterator
 org.apache.ignite.internal.processors.cache.persistence.IgniteCacheDatabaseSharedManager$1
+org.apache.ignite.internal.processors.cache.persistence.StorageException
 org.apache.ignite.internal.processors.cache.persistence.checkpoint.CheckpointEntryType
 org.apache.ignite.internal.processors.cache.persistence.file.AsyncFileIOFactory
-org.apache.ignite.internal.processors.cache.persistence.file.FileDownloader$1
+org.apache.ignite.internal.processors.cache.persistence.file.EncryptedFileIOFactory
 org.apache.ignite.internal.processors.cache.persistence.file.FileIOFactory
-org.apache.ignite.internal.processors.cache.persistence.file.PersistentStorageIOException
+org.apache.ignite.internal.processors.cache.persistence.file.FilePageStoreManager$IdxCacheStores
 org.apache.ignite.internal.processors.cache.persistence.file.RandomAccessFileIOFactory
+org.apache.ignite.internal.processors.cache.persistence.freelist.CorruptedFreeListException
 org.apache.ignite.internal.processors.cache.persistence.migration.UpgradePendingTreeToPerPartitionTask
 org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryImpl$Segment
 org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryImpl$ThrottlingPolicy
@@ -1012,15 +1085,16 @@ org.apache.ignite.internal.processors.cache.persistence.snapshot.SnapshotOperati
 org.apache.ignite.internal.processors.cache.persistence.snapshot.TrackingPageIsCorruptedException
 org.apache.ignite.internal.processors.cache.persistence.tree.BPlusTree$Bool
 org.apache.ignite.internal.processors.cache.persistence.tree.BPlusTree$Result
+org.apache.ignite.internal.processors.cache.persistence.tree.CorruptedTreeException
 org.apache.ignite.internal.processors.cache.persistence.tree.io.DataPageIO$EntryPart
 org.apache.ignite.internal.processors.cache.persistence.tree.reuse.LongListReuseBag
 org.apache.ignite.internal.processors.cache.persistence.wal.AbstractWalRecordsIterator
 org.apache.ignite.internal.processors.cache.persistence.wal.AbstractWalRecordsIterator$StartSeekingFilter
 org.apache.ignite.internal.processors.cache.persistence.wal.FileWALPointer
-org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager$7
+org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager$6
 org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager$FileArchiver$1
 org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager$FileArchiver$2
-org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager$FileCompressor$1
+org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager$FileCompressorWorker$1
 org.apache.ignite.internal.processors.cache.persistence.wal.FileWriteAheadLogManager$RecordsIterator
 org.apache.ignite.internal.processors.cache.persistence.wal.SegmentEofException
 org.apache.ignite.internal.processors.cache.persistence.wal.SegmentedRingByteBuffer$BufferMode
@@ -1029,6 +1103,7 @@ org.apache.ignite.internal.processors.cache.persistence.wal.SingleSegmentLogical
 org.apache.ignite.internal.processors.cache.persistence.wal.WalSegmentTailReachedException
 org.apache.ignite.internal.processors.cache.persistence.wal.crc.IgniteDataIntegrityViolationException
 org.apache.ignite.internal.processors.cache.persistence.wal.reader.StandaloneWalRecordsIterator
+org.apache.ignite.internal.processors.cache.persistence.wal.reader.StrictBoundsCheckException
 org.apache.ignite.internal.processors.cache.query.CacheQueryEntry
 org.apache.ignite.internal.processors.cache.query.CacheQueryType
 org.apache.ignite.internal.processors.cache.query.GridCacheDistributedQueryFuture$1
@@ -1038,6 +1113,7 @@ org.apache.ignite.internal.processors.cache.query.GridCacheDistributedQueryManag
 org.apache.ignite.internal.processors.cache.query.GridCacheDistributedQueryManager$5
 org.apache.ignite.internal.processors.cache.query.GridCacheDistributedQueryManager$6
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryAdapter$1
+org.apache.ignite.internal.processors.cache.query.GridCacheQueryAdapter$MvccTrackingIterator
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryAdapter$ScanQueryFallbackClosableIterator
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryDetailMetricsAdapter
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryFutureAdapter$1
@@ -1049,7 +1125,6 @@ org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$5
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$6
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$7
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$8
-org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$9
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$CacheSqlIndexMetadata
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$CacheSqlMetadata
 org.apache.ignite.internal.processors.cache.query.GridCacheQueryManager$CachedResult$QueueIterator
@@ -1082,7 +1157,6 @@ org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQuer
 org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryEvent
 org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryHandler
 org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryHandler$1
-org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryHandler$2$1
 org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryHandler$ContinuousQueryAsyncClosure$1
 org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryHandlerV2
 org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryHandlerV3
@@ -1125,6 +1199,7 @@ org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$15
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$16
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$17
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$18
+org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$19
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$2
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$3
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxHandler$4
@@ -1150,7 +1225,6 @@ org.apache.ignite.internal.processors.cache.transactions.IgniteTxManager$4
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxManager$5
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxManager$CommitListener
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxManager$CommittedVersion
-org.apache.ignite.internal.processors.cache.transactions.IgniteTxManager$NodeFailureTimeoutObject$1
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxMap
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxMap$1
 org.apache.ignite.internal.processors.cache.transactions.IgniteTxMap$1$1
@@ -1168,13 +1242,17 @@ org.apache.ignite.internal.processors.cache.transactions.TxLock
 org.apache.ignite.internal.processors.cache.transactions.TxLockList
 org.apache.ignite.internal.processors.cache.transactions.TxLocksRequest
 org.apache.ignite.internal.processors.cache.transactions.TxLocksResponse
+org.apache.ignite.internal.processors.cache.tree.mvcc.data.ResultType
 org.apache.ignite.internal.processors.cache.verify.CacheInfo
 org.apache.ignite.internal.processors.cache.verify.CollectConflictPartitionKeysTask
 org.apache.ignite.internal.processors.cache.verify.CollectConflictPartitionKeysTask$CollectPartitionEntryHashesJob
 org.apache.ignite.internal.processors.cache.verify.ContentionClosure
 org.apache.ignite.internal.processors.cache.verify.ContentionInfo
+org.apache.ignite.internal.processors.cache.verify.GridNotIdleException
 org.apache.ignite.internal.processors.cache.verify.IdleVerifyDumpResult
+org.apache.ignite.internal.processors.cache.verify.IdleVerifyException
 org.apache.ignite.internal.processors.cache.verify.IdleVerifyResultV2
+org.apache.ignite.internal.processors.cache.verify.NoMatchingCachesException
 org.apache.ignite.internal.processors.cache.verify.PartitionEntryHashRecord
 org.apache.ignite.internal.processors.cache.verify.PartitionHashRecord
 org.apache.ignite.internal.processors.cache.verify.PartitionHashRecordV2
@@ -1214,6 +1292,7 @@ org.apache.ignite.internal.processors.closure.GridClosureProcessor$T8
 org.apache.ignite.internal.processors.closure.GridClosureProcessor$T9
 org.apache.ignite.internal.processors.closure.GridClosureProcessor$TaskNoReduceAdapter
 org.apache.ignite.internal.processors.closure.GridPeerDeployAwareTaskAdapter
+org.apache.ignite.internal.processors.cluster.BaselineAdjustForbiddenException
 org.apache.ignite.internal.processors.cluster.BaselineTopology
 org.apache.ignite.internal.processors.cluster.BaselineTopologyHistory
 org.apache.ignite.internal.processors.cluster.BaselineTopologyHistoryItem
@@ -1234,6 +1313,10 @@ org.apache.ignite.internal.processors.cluster.GridClusterStateProcessor$7
 org.apache.ignite.internal.processors.cluster.GridClusterStateProcessor$BaselineStateAndHistoryData
 org.apache.ignite.internal.processors.cluster.GridClusterStateProcessor$CheckGlobalStateComputeRequest
 org.apache.ignite.internal.processors.cluster.GridClusterStateProcessor$ClientChangeGlobalStateComputeRequest
+org.apache.ignite.internal.processors.cluster.baseline.autoadjust.BaselineAutoAdjustStatus$TaskState
+org.apache.ignite.internal.processors.configuration.distributed.DetachedPropertyException
+org.apache.ignite.internal.processors.configuration.distributed.DistributedConfigurationProcessor$AllowableAction
+org.apache.ignite.internal.processors.configuration.distributed.NotWritablePropertyException
 org.apache.ignite.internal.processors.continuous.AbstractContinuousMessage
 org.apache.ignite.internal.processors.continuous.ContinuousRoutineInfo
 org.apache.ignite.internal.processors.continuous.ContinuousRoutineStartResultMessage
@@ -1438,8 +1521,18 @@ org.apache.ignite.internal.processors.marshaller.MappingProposedMessage$Proposal
 org.apache.ignite.internal.processors.marshaller.MarshallerMappingItem
 org.apache.ignite.internal.processors.marshaller.MissingMappingRequestMessage
 org.apache.ignite.internal.processors.marshaller.MissingMappingResponseMessage
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageCasAckMessage
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageCasMessage
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageClusterNodeData
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageHistoryItem
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageJoiningNodeData
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageKeyValuePair
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageUpdateAckMessage
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageUpdateMessage
+org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageVersion
 org.apache.ignite.internal.processors.odbc.jdbc.JdbcRequestHandler$1
 org.apache.ignite.internal.processors.odbc.jdbc.JdbcStatementType
+org.apache.ignite.internal.processors.odbc.odbc.OdbcRequestHandler$1
 org.apache.ignite.internal.processors.odbc.odbc.escape.OdbcEscapeType
 org.apache.ignite.internal.processors.platform.PlatformAbstractConfigurationClosure
 org.apache.ignite.internal.processors.platform.PlatformAbstractPredicate
@@ -1514,23 +1607,26 @@ org.apache.ignite.internal.processors.platform.utils.PlatformFutureUtils$FutureL
 org.apache.ignite.internal.processors.platform.utils.PlatformFutureUtils$InternalFutureListenable$1
 org.apache.ignite.internal.processors.platform.websession.PlatformDotNetSessionLockProcessor
 org.apache.ignite.internal.processors.platform.websession.PlatformDotNetSessionSetAndUnlockProcessor
+org.apache.ignite.internal.processors.query.EnlistOperation
 org.apache.ignite.internal.processors.query.GridQueryFieldMetadata
+org.apache.ignite.internal.processors.query.GridQueryProcessor$3
 org.apache.ignite.internal.processors.query.GridQueryProcessor$4
 org.apache.ignite.internal.processors.query.GridQueryProcessor$5
-org.apache.ignite.internal.processors.query.GridQueryProcessor$6
 org.apache.ignite.internal.processors.query.GridQueryProcessor$7
-org.apache.ignite.internal.processors.query.GridQueryProcessor$8
-org.apache.ignite.internal.processors.query.GridQueryProcessor$9
 org.apache.ignite.internal.processors.query.GridQueryProcessor$SchemaOperation$1
 org.apache.ignite.internal.processors.query.IgniteSQLException
+org.apache.ignite.internal.processors.query.NestedTxMode
 org.apache.ignite.internal.processors.query.QueryEntityEx
 org.apache.ignite.internal.processors.query.QueryField
 org.apache.ignite.internal.processors.query.QueryIndexKey
 org.apache.ignite.internal.processors.query.QuerySchema
+org.apache.ignite.internal.processors.query.UpdateSourceIterator
 org.apache.ignite.internal.processors.query.h2.twostep.messages.GridQueryCancelRequest
 org.apache.ignite.internal.processors.query.h2.twostep.messages.GridQueryFailResponse
 org.apache.ignite.internal.processors.query.h2.twostep.messages.GridQueryNextPageRequest
 org.apache.ignite.internal.processors.query.h2.twostep.messages.GridQueryNextPageResponse
+org.apache.ignite.internal.processors.query.messages.GridQueryKillRequest
+org.apache.ignite.internal.processors.query.messages.GridQueryKillResponse
 org.apache.ignite.internal.processors.query.schema.SchemaOperationException
 org.apache.ignite.internal.processors.query.schema.SchemaOperationManager$1
 org.apache.ignite.internal.processors.query.schema.SchemaOperationWorker$1
@@ -1604,6 +1700,7 @@ org.apache.ignite.internal.processors.rest.handlers.cache.GridCacheCommandHandle
 org.apache.ignite.internal.processors.rest.handlers.cache.GridCacheCommandHandler$SizeCommand
 org.apache.ignite.internal.processors.rest.handlers.cache.GridCacheCommandHandler$UpdateTllCommand
 org.apache.ignite.internal.processors.rest.handlers.cache.GridCacheRestResponse
+org.apache.ignite.internal.processors.rest.handlers.cluster.GridBaselineCommandResponse
 org.apache.ignite.internal.processors.rest.handlers.datastructures.DataStructuresCommandHandler$1
 org.apache.ignite.internal.processors.rest.handlers.query.CacheQueryFieldsMetaResult
 org.apache.ignite.internal.processors.rest.handlers.query.CacheQueryResult
@@ -1613,7 +1710,6 @@ org.apache.ignite.internal.processors.rest.handlers.redis.exception.GridRedisGen
 org.apache.ignite.internal.processors.rest.handlers.redis.exception.GridRedisTypeException
 org.apache.ignite.internal.processors.rest.handlers.task.GridTaskCommandHandler$2
 org.apache.ignite.internal.processors.rest.handlers.task.GridTaskCommandHandler$ExeCallable
-org.apache.ignite.internal.processors.rest.handlers.task.GridTaskCommandHandler$TaskDescriptor
 org.apache.ignite.internal.processors.rest.handlers.task.GridTaskResultRequest
 org.apache.ignite.internal.processors.rest.handlers.task.GridTaskResultResponse
 org.apache.ignite.internal.processors.rest.handlers.top.GridTopologyCommandHandler$1
@@ -1640,20 +1736,44 @@ org.apache.ignite.internal.processors.service.GridServiceProxy
 org.apache.ignite.internal.processors.service.GridServiceProxy$ServiceProxyCallable
 org.apache.ignite.internal.processors.service.GridServiceProxy$ServiceProxyException
 org.apache.ignite.internal.processors.service.LazyServiceConfiguration
+org.apache.ignite.internal.processors.service.ServiceChangeAbstractRequest
+org.apache.ignite.internal.processors.service.ServiceChangeBatchRequest
+org.apache.ignite.internal.processors.service.ServiceClusterDeploymentResult
+org.apache.ignite.internal.processors.service.ServiceClusterDeploymentResultBatch
 org.apache.ignite.internal.processors.service.ServiceContextImpl
+org.apache.ignite.internal.processors.service.ServiceDeploymentProcessId
+org.apache.ignite.internal.processors.service.ServiceDeploymentRequest
 org.apache.ignite.internal.processors.service.ServiceDescriptorImpl
+org.apache.ignite.internal.processors.service.ServiceInfo
+org.apache.ignite.internal.processors.service.ServiceProcessorCommonDiscoveryData
+org.apache.ignite.internal.processors.service.ServiceProcessorJoinNodeDiscoveryData
+org.apache.ignite.internal.processors.service.ServiceSingleNodeDeploymentResult
+org.apache.ignite.internal.processors.service.ServiceSingleNodeDeploymentResultBatch
+org.apache.ignite.internal.processors.service.ServiceUndeploymentRequest
 org.apache.ignite.internal.processors.task.GridTaskProcessor$1
 org.apache.ignite.internal.processors.task.GridTaskThreadContextKey
 org.apache.ignite.internal.processors.task.GridTaskWorker$3
 org.apache.ignite.internal.processors.task.GridTaskWorker$5
 org.apache.ignite.internal.processors.task.GridTaskWorker$State
+org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor$2
 org.apache.ignite.internal.sql.SqlLexerTokenType
 org.apache.ignite.internal.sql.SqlParseException
 org.apache.ignite.internal.sql.SqlStrictParseException
+org.apache.ignite.internal.sql.optimizer.affinity.PartitionAffinityFunctionType
+org.apache.ignite.internal.sql.optimizer.affinity.PartitionCompositeNodeOperator
+org.apache.ignite.internal.sql.optimizer.affinity.PartitionParameterType
+org.apache.ignite.internal.stat.IndexPageType
+org.apache.ignite.internal.stat.IoStatisticsType
+org.apache.ignite.internal.transactions.IgniteTxAlreadyCompletedCheckedException
+org.apache.ignite.internal.transactions.IgniteTxDuplicateKeyCheckedException
 org.apache.ignite.internal.transactions.IgniteTxHeuristicCheckedException
 org.apache.ignite.internal.transactions.IgniteTxOptimisticCheckedException
 org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException
+org.apache.ignite.internal.transactions.IgniteTxSerializationCheckedException
 org.apache.ignite.internal.transactions.IgniteTxTimeoutCheckedException
+org.apache.ignite.internal.transactions.IgniteTxUnexpectedStateCheckedException
+org.apache.ignite.internal.transactions.TransactionCheckedException
+org.apache.ignite.internal.util.BitSetIntSet
 org.apache.ignite.internal.util.F0$1
 org.apache.ignite.internal.util.F0$2
 org.apache.ignite.internal.util.F0$3
@@ -1728,14 +1848,17 @@ org.apache.ignite.internal.util.IgniteUtils$12
 org.apache.ignite.internal.util.IgniteUtils$13
 org.apache.ignite.internal.util.IgniteUtils$14
 org.apache.ignite.internal.util.IgniteUtils$15
+org.apache.ignite.internal.util.IgniteUtils$16
 org.apache.ignite.internal.util.IgniteUtils$17
-org.apache.ignite.internal.util.IgniteUtils$23
-org.apache.ignite.internal.util.IgniteUtils$24
-org.apache.ignite.internal.util.IgniteUtils$25
+org.apache.ignite.internal.util.IgniteUtils$18
+org.apache.ignite.internal.util.IgniteUtils$20
 org.apache.ignite.internal.util.IgniteUtils$26
 org.apache.ignite.internal.util.IgniteUtils$27
 org.apache.ignite.internal.util.IgniteUtils$28
+org.apache.ignite.internal.util.IgniteUtils$29
 org.apache.ignite.internal.util.IgniteUtils$3
+org.apache.ignite.internal.util.IgniteUtils$30
+org.apache.ignite.internal.util.IgniteUtils$31
 org.apache.ignite.internal.util.IgniteUtils$4
 org.apache.ignite.internal.util.IgniteUtils$5
 org.apache.ignite.internal.util.IgniteUtils$6
@@ -1809,6 +1932,8 @@ org.apache.ignite.internal.util.lang.IgniteReducer3
 org.apache.ignite.internal.util.lang.IgniteReducer3X
 org.apache.ignite.internal.util.lang.IgniteReducerX
 org.apache.ignite.internal.util.lang.IgniteSingletonIterator
+org.apache.ignite.internal.util.lang.IgniteThrowableConsumer
+org.apache.ignite.internal.util.lang.IgniteThrowableFunction
 org.apache.ignite.internal.util.lang.gridfunc.AlwaysFalsePredicate
 org.apache.ignite.internal.util.lang.gridfunc.AlwaysTruePredicate
 org.apache.ignite.internal.util.lang.gridfunc.AlwaysTrueReducer
@@ -1877,13 +2002,6 @@ org.apache.ignite.internal.util.offheap.unsafe.GridUnsafeMap$Segment$2
 org.apache.ignite.internal.util.offheap.unsafe.GridUnsafePartitionedMap$2
 org.apache.ignite.internal.util.offheap.unsafe.GridUnsafePartitionedMap$3
 org.apache.ignite.internal.util.offheap.unsafe.GridUnsafePartitionedMap$PartitionedMapCloseableIterator
-org.apache.ignite.internal.util.snaptree.CopyOnWriteManager$COWEpoch
-org.apache.ignite.internal.util.snaptree.CopyOnWriteManager$Latch
-org.apache.ignite.internal.util.snaptree.Epoch$Root
-org.apache.ignite.internal.util.snaptree.EpochNode
-org.apache.ignite.internal.util.snaptree.EpochNode$Child
-org.apache.ignite.internal.util.snaptree.SnapTreeMap
-org.apache.ignite.internal.util.snaptree.SnapTreeMap$SubMap
 org.apache.ignite.internal.util.tostring.SBLimitedLength
 org.apache.ignite.internal.util.typedef.C1
 org.apache.ignite.internal.util.typedef.C2
@@ -1925,6 +2043,7 @@ org.apache.ignite.internal.visor.VisorJob
 org.apache.ignite.internal.visor.VisorMultiNodeTask
 org.apache.ignite.internal.visor.VisorOneNodeTask
 org.apache.ignite.internal.visor.VisorTaskArgument
+org.apache.ignite.internal.visor.baseline.VisorBaselineAutoAdjustSettings
 org.apache.ignite.internal.visor.baseline.VisorBaselineNode
 org.apache.ignite.internal.visor.baseline.VisorBaselineOperation
 org.apache.ignite.internal.visor.baseline.VisorBaselineTask
@@ -2005,6 +2124,15 @@ org.apache.ignite.internal.visor.cache.VisorCacheStopTask
 org.apache.ignite.internal.visor.cache.VisorCacheStopTask$VisorCacheStopJob
 org.apache.ignite.internal.visor.cache.VisorCacheStopTaskArg
 org.apache.ignite.internal.visor.cache.VisorCacheStoreConfiguration
+org.apache.ignite.internal.visor.cache.VisorCacheToggleStatisticsTask
+org.apache.ignite.internal.visor.cache.VisorCacheToggleStatisticsTask$VisorCachesToggleStatisticsJob
+org.apache.ignite.internal.visor.cache.VisorCacheToggleStatisticsTaskArg
+org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceClosure
+org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceJobResult
+org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTask
+org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTask$FindAndDeleteGarbageInPersistenceJob
+org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTaskArg
+org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTaskResult
 org.apache.ignite.internal.visor.cache.VisorMemoryMetrics
 org.apache.ignite.internal.visor.cache.VisorModifyCacheMode
 org.apache.ignite.internal.visor.cache.VisorPartitionMap
@@ -2090,6 +2218,11 @@ org.apache.ignite.internal.visor.node.VisorBasicConfiguration
 org.apache.ignite.internal.visor.node.VisorBinaryConfiguration
 org.apache.ignite.internal.visor.node.VisorBinaryTypeConfiguration
 org.apache.ignite.internal.visor.node.VisorCacheKeyConfiguration
+org.apache.ignite.internal.visor.node.VisorCacheRebalanceCollectorJobResult
+org.apache.ignite.internal.visor.node.VisorCacheRebalanceCollectorTask
+org.apache.ignite.internal.visor.node.VisorCacheRebalanceCollectorTask$VisorCacheRebalanceCollectorJob
+org.apache.ignite.internal.visor.node.VisorCacheRebalanceCollectorTaskArg
+org.apache.ignite.internal.visor.node.VisorCacheRebalanceCollectorTaskResult
 org.apache.ignite.internal.visor.node.VisorClientConnectorConfiguration
 org.apache.ignite.internal.visor.node.VisorDataRegionConfiguration
 org.apache.ignite.internal.visor.node.VisorDataStorageConfiguration
@@ -2102,6 +2235,8 @@ org.apache.ignite.internal.visor.node.VisorLifecycleConfiguration
 org.apache.ignite.internal.visor.node.VisorMemoryConfiguration
 org.apache.ignite.internal.visor.node.VisorMemoryPolicyConfiguration
 org.apache.ignite.internal.visor.node.VisorMetricsConfiguration
+org.apache.ignite.internal.visor.node.VisorMvccConfiguration
+org.apache.ignite.internal.visor.node.VisorNodeBaselineStatus
 org.apache.ignite.internal.visor.node.VisorNodeConfigurationCollectorJob
 org.apache.ignite.internal.visor.node.VisorNodeConfigurationCollectorTask
 org.apache.ignite.internal.visor.node.VisorNodeDataCollectorJob
@@ -2151,6 +2286,8 @@ org.apache.ignite.internal.visor.query.VisorQueryDetailMetricsCollectorTask
 org.apache.ignite.internal.visor.query.VisorQueryDetailMetricsCollectorTask$VisorCacheQueryDetailMetricsCollectorJob
 org.apache.ignite.internal.visor.query.VisorQueryDetailMetricsCollectorTaskArg
 org.apache.ignite.internal.visor.query.VisorQueryEntity
+org.apache.ignite.internal.visor.query.VisorQueryFetchFirstPageTask
+org.apache.ignite.internal.visor.query.VisorQueryFetchFirstPageTask$VisorQueryFetchFirstPageJob
 org.apache.ignite.internal.visor.query.VisorQueryField
 org.apache.ignite.internal.visor.query.VisorQueryIndex
 org.apache.ignite.internal.visor.query.VisorQueryIndexField
@@ -2158,6 +2295,9 @@ org.apache.ignite.internal.visor.query.VisorQueryMetrics
 org.apache.ignite.internal.visor.query.VisorQueryNextPageTask
 org.apache.ignite.internal.visor.query.VisorQueryNextPageTask$VisorQueryNextPageJob
 org.apache.ignite.internal.visor.query.VisorQueryNextPageTaskArg
+org.apache.ignite.internal.visor.query.VisorQueryPingTask
+org.apache.ignite.internal.visor.query.VisorQueryPingTask$VisorQueryFetchFirstPageJob
+org.apache.ignite.internal.visor.query.VisorQueryPingTaskResult
 org.apache.ignite.internal.visor.query.VisorQueryResetDetailMetricsTask
 org.apache.ignite.internal.visor.query.VisorQueryResetDetailMetricsTask$VisorCacheResetQueryDetailMetricsJob
 org.apache.ignite.internal.visor.query.VisorQueryResetMetricsTask
@@ -2181,7 +2321,16 @@ org.apache.ignite.internal.visor.service.VisorCancelServiceTaskArg
 org.apache.ignite.internal.visor.service.VisorServiceDescriptor
 org.apache.ignite.internal.visor.service.VisorServiceTask
 org.apache.ignite.internal.visor.service.VisorServiceTask$VisorServiceJob
+org.apache.ignite.internal.visor.tx.FetchNearXidVersionTask
+org.apache.ignite.internal.visor.tx.FetchNearXidVersionTask$FetchNearXidVersionJob
+org.apache.ignite.internal.visor.tx.TxKeyLockType
+org.apache.ignite.internal.visor.tx.TxMappingType
+org.apache.ignite.internal.visor.tx.TxVerboseId
+org.apache.ignite.internal.visor.tx.TxVerboseInfo
+org.apache.ignite.internal.visor.tx.TxVerboseKey
 org.apache.ignite.internal.visor.tx.VisorTxInfo
+org.apache.ignite.internal.visor.tx.VisorTxInfo$1
+org.apache.ignite.internal.visor.tx.VisorTxInfo$2
 org.apache.ignite.internal.visor.tx.VisorTxOperation
 org.apache.ignite.internal.visor.tx.VisorTxProjection
 org.apache.ignite.internal.visor.tx.VisorTxSortOrder
@@ -2191,6 +2340,7 @@ org.apache.ignite.internal.visor.tx.VisorTxTask$2
 org.apache.ignite.internal.visor.tx.VisorTxTask$3
 org.apache.ignite.internal.visor.tx.VisorTxTask$4
 org.apache.ignite.internal.visor.tx.VisorTxTask$5
+org.apache.ignite.internal.visor.tx.VisorTxTask$LocalKillClosure
 org.apache.ignite.internal.visor.tx.VisorTxTask$NearKillClosure
 org.apache.ignite.internal.visor.tx.VisorTxTask$RemoteKillClosure
 org.apache.ignite.internal.visor.tx.VisorTxTask$TxKillClosure
@@ -2201,8 +2351,9 @@ org.apache.ignite.internal.visor.util.VisorClusterGroupEmptyException
 org.apache.ignite.internal.visor.util.VisorEventMapper
 org.apache.ignite.internal.visor.util.VisorExceptionWrapper
 org.apache.ignite.internal.visor.util.VisorTaskUtils$4
-org.apache.ignite.internal.visor.verify.IndexValidationIssue
+org.apache.ignite.internal.visor.verify.CacheFilterEnum
 org.apache.ignite.internal.visor.verify.IndexIntegrityCheckIssue
+org.apache.ignite.internal.visor.verify.IndexValidationIssue
 org.apache.ignite.internal.visor.verify.ValidateIndexesPartitionResult
 org.apache.ignite.internal.visor.verify.VisorContentionJobResult
 org.apache.ignite.internal.visor.verify.VisorContentionTask
@@ -2218,15 +2369,12 @@ org.apache.ignite.internal.visor.verify.VisorIdleAnalyzeTaskResult
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyDumpTask
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyDumpTaskArg
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyJob
-org.apache.ignite.internal.visor.verify.VisorIdleVerifyJob$1
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyTask
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyTask$VisorIdleVerifyJob
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyTask$VisorIdleVerifyJob$1
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyTaskArg
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyTaskResult
 org.apache.ignite.internal.visor.verify.VisorIdleVerifyTaskV2
-org.apache.ignite.internal.visor.verify.VisorIdleVerifyTaskV2$VisorIdleVerifyJobV2
-org.apache.ignite.internal.visor.verify.VisorIdleVerifyTaskV2$VisorIdleVerifyJobV2$1
 org.apache.ignite.internal.visor.verify.VisorValidateIndexesJobResult
 org.apache.ignite.internal.visor.verify.VisorValidateIndexesTaskArg
 org.apache.ignite.internal.visor.verify.VisorValidateIndexesTaskResult
@@ -2294,6 +2442,7 @@ org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$1
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$10
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$2$1
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$2$2
+org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$2$3
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$2$ConnectClosure
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$2$ConnectClosure$1
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$2$ConnectClosureNew
@@ -2302,11 +2451,11 @@ org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$3
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$4
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$9
 org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$HandshakeClosure
-org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$HandshakeException
-org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi$HandshakeTimeoutException
+org.apache.ignite.spi.communication.tcp.internal.HandshakeException
 org.apache.ignite.spi.communication.tcp.internal.TcpCommunicationConnectionCheckFuture$SingleAddressConnectFuture$1
 org.apache.ignite.spi.communication.tcp.messages.HandshakeMessage
 org.apache.ignite.spi.communication.tcp.messages.HandshakeMessage2
+org.apache.ignite.spi.communication.tcp.messages.HandshakeWaitMessage
 org.apache.ignite.spi.communication.tcp.messages.NodeIdMessage
 org.apache.ignite.spi.communication.tcp.messages.RecoveryLastReceivedMessage
 org.apache.ignite.spi.discovery.DiscoverySpiCustomMessage
@@ -2332,6 +2481,7 @@ org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryClientReconnectMessage
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryConnectionCheckMessage
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryCustomEventMessage
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryDiscardMessage
+org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryDummyWakeupMessage
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryDuplicateIdMessage
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryHandshakeRequest
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryHandshakeResponse
@@ -2349,6 +2499,7 @@ org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryPingResponse
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryRingLatencyCheckMessage
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryServerOnlyCustomEventMessage
 org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryStatusCheckMessage
+org.apache.ignite.spi.encryption.keystore.KeystoreEncryptionKey
 org.apache.ignite.ssl.SslContextFactory
 org.apache.ignite.startup.BasicWarmupClosure
 org.apache.ignite.startup.cmdline.AboutDialog
@@ -2359,14 +2510,19 @@ org.apache.ignite.stream.StreamTransformer$1
 org.apache.ignite.stream.StreamTransformer$EntryProcessorWrapper
 org.apache.ignite.stream.StreamVisitor
 org.apache.ignite.stream.StreamVisitor$1
+org.apache.ignite.transactions.TransactionAlreadyCompletedException
 org.apache.ignite.transactions.TransactionConcurrency
 org.apache.ignite.transactions.TransactionDeadlockException
+org.apache.ignite.transactions.TransactionDuplicateKeyException
 org.apache.ignite.transactions.TransactionException
 org.apache.ignite.transactions.TransactionHeuristicException
 org.apache.ignite.transactions.TransactionIsolation
 org.apache.ignite.transactions.TransactionMetrics
+org.apache.ignite.transactions.TransactionMixedModeException
 org.apache.ignite.transactions.TransactionOptimisticException
 org.apache.ignite.transactions.TransactionRollbackException
+org.apache.ignite.transactions.TransactionSerializationException
 org.apache.ignite.transactions.TransactionState
 org.apache.ignite.transactions.TransactionTimeoutException
+org.apache.ignite.transactions.TransactionUnsupportedConcurrencyException
 org.apache.ignite.util.AttributeNodeFilter
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandArgFactory.java b/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandArgFactory.java
index 2ea98cd..b7cd1cc 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandArgFactory.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandArgFactory.java
@@ -20,6 +20,7 @@ package org.apache.ignite.internal.commandline;
 import org.apache.ignite.internal.commandline.argument.CommandArg;
 import org.apache.ignite.internal.commandline.cache.CacheCommand;
 import org.apache.ignite.internal.commandline.cache.argument.DistributionCommandArg;
+import org.apache.ignite.internal.commandline.cache.argument.FindAndDeleteGarbageArg;
 import org.apache.ignite.internal.commandline.cache.argument.IdleVerifyCommandArg;
 import org.apache.ignite.internal.commandline.cache.argument.ListCommandArg;
 import org.apache.ignite.internal.commandline.cache.argument.ValidateIndexesCommandArg;
@@ -50,6 +51,9 @@ public class CommandArgFactory {
 
             case VALIDATE_INDEXES:
                 return ValidateIndexesCommandArg.values();
+
+            case FIND_AND_DELETE_GARBAGE:
+                return FindAndDeleteGarbageArg.values();
         }
 
         throw new IllegalArgumentException("Unknown cache command " + cmd);
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandHandlerParsingTest.java b/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandHandlerParsingTest.java
index 3239171..02453dc 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandHandlerParsingTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/commandline/CommandHandlerParsingTest.java
@@ -17,10 +17,15 @@
 
 package org.apache.ignite.internal.commandline;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import java.util.UUID;
+import java.util.function.Predicate;
 import org.apache.ignite.internal.commandline.cache.CacheArguments;
+import org.apache.ignite.internal.commandline.cache.argument.FindAndDeleteGarbageArg;
+import org.apache.ignite.internal.util.typedef.T2;
 import org.apache.ignite.internal.visor.tx.VisorTxOperation;
 import org.apache.ignite.internal.visor.tx.VisorTxProjection;
 import org.apache.ignite.internal.visor.tx.VisorTxSortOrder;
@@ -412,9 +417,8 @@ public class CommandHandlerParsingTest {
     @Test
     public void testTransactionArguments() {
         CommandHandler hnd = new CommandHandler();
-        Arguments args;
 
-        args = hnd.parseAndValidate(asList("--tx"));
+        hnd.parseAndValidate(asList("--tx"));
 
         try {
             hnd.parseAndValidate(asList("--tx", "minDuration"));
@@ -472,7 +476,7 @@ public class CommandHandlerParsingTest {
         catch (IllegalArgumentException ignored) {
         }
 
-        args = hnd.parseAndValidate(asList("--tx", "--min-duration", "120", "--min-size", "10", "--limit", "100", "--order", "SIZE",
+        Arguments args = hnd.parseAndValidate(asList("--tx", "--min-duration", "120", "--min-size", "10", "--limit", "100", "--order", "SIZE",
             "--servers"));
 
         VisorTxTaskArg arg = args.transactionArguments();
@@ -501,4 +505,125 @@ public class CommandHandlerParsingTest {
         assertNull(arg.getProjection());
         assertEquals(Arrays.asList("1", "2", "3"), arg.getConsistentIds());
     }
+
+    /**
+     * Test parsing arguments by find_garbage command.
+     */
+    @Test
+    public void testFindAndDeleteGarbage() {
+        CommandHandler hnd = new CommandHandler();
+
+        String nodeId = UUID.randomUUID().toString();
+        String delete = FindAndDeleteGarbageArg.DELETE.toString();
+        String groups = "group1,grpoup2,group3";
+
+        List<List<String>> lists = generateArgumentList(
+            "find_garbage",
+            new T2<>(nodeId, false),
+            new T2<>(delete, false),
+            new T2<>(groups, false)
+        );
+
+        for (List<String> list : lists) {
+            Arguments arg = hnd.parseAndValidate(list);
+
+            CacheArguments args = arg.cacheArgs();
+
+            if (list.contains(nodeId))
+                assertEquals("nodeId parameter unexpected value", nodeId, args.nodeId().toString());
+            else
+                assertNull(args.nodeId());
+
+            assertEquals(list.contains(delete), args.delete());
+
+            if (list.contains(groups))
+                assertEquals(3, args.groups().size());
+            else
+                assertNull(args.groups());
+        }
+    }
+
+    /**
+     * @param subcommand Cache subcommand.
+     * @param optional List of arguments, where second param is this argument is stopping one or not.
+     *  Every argument treated as optional.
+     *
+     * @return List of every possible combinations of the arguments {[], [1], [2], [3], [1,2], [2,1], [1.3], [3,1], [1,2,3]...}.
+     */
+    private List<List<String>> generateArgumentList(String subcommand, T2<String, Boolean>...optional) {
+        List<List<T2<String, Boolean>>> lists = generateAllCombinations(Arrays.asList(optional), (x) -> x.get2());
+
+        ArrayList<List<String>> res = new ArrayList<>();
+
+        ArrayList<String> empty = new ArrayList<>();
+
+        empty.add(CACHE.text());
+        empty.add(subcommand);
+
+        res.add(empty);
+
+        for (List<T2<String, Boolean>> list : lists) {
+            ArrayList<String> arg = new ArrayList<>(empty);
+
+            list.forEach(x -> arg.add(x.get1()));
+
+            res.add(arg);
+        }
+
+        return res;
+    }
+
+    /**
+     * @param source Source of elements.
+     * @param stopFunc Stop function.
+     */
+    private <T> List<List<T>> generateAllCombinations(List<T> source, Predicate<T> stopFunc) {
+        List<List<T>> res = new ArrayList<>();
+
+        for (int i = 0; i < source.size(); i++) {
+            List<T> sourceCopy = new ArrayList<>(source);
+
+            T removed = sourceCopy.remove(i);
+
+            generateAllCombinations(Collections.singletonList(removed), sourceCopy, stopFunc, res);
+        }
+
+        return res;
+    }
+
+
+    /**
+     * @param res Intermidiate result.
+     * @param source Source of left elements.
+     * @param stopFunc Stop function.
+     * @param acc Ready result accumulator.
+     */
+    private <T> void generateAllCombinations(List<T> res, List<T> source, Predicate<T> stopFunc, List<List<T>> acc) {
+        acc.add(res);
+
+        if (stopFunc != null && stopFunc.test(res.get(res.size() - 1)))
+            return;
+
+        if (source.size() == 1) {
+            List<T> list = new ArrayList<>(res);
+
+            list.add(source.get(0));
+
+            acc.add(list);
+
+            return;
+        }
+
+        for (int i = 0; i < source.size(); i++) {
+            ArrayList<T> res0 = new ArrayList<>(res);
+
+            List<T> sourceCopy = new ArrayList<>(source);
+
+            T removed = sourceCopy.remove(i);
+
+            res0.add(removed);
+
+            generateAllCombinations(res0, sourceCopy, stopFunc, acc);
+        }
+    }
 }
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java
index 4165dfe..1424a25 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java
@@ -40,9 +40,12 @@ import org.apache.ignite.internal.GridKernalContext;
 import org.apache.ignite.internal.IgniteInternalFuture;
 import org.apache.ignite.internal.IgniteKernal;
 import org.apache.ignite.internal.managers.IgniteMBeansManager;
+import org.apache.ignite.internal.pagemem.PageMemory;
 import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
 import org.apache.ignite.internal.processors.cache.mvcc.MvccSnapshot;
 import org.apache.ignite.internal.processors.cache.persistence.CacheDataRow;
+import org.apache.ignite.internal.processors.cache.persistence.RootPage;
+import org.apache.ignite.internal.processors.cache.persistence.tree.reuse.ReuseList;
 import org.apache.ignite.internal.processors.odbc.jdbc.JdbcParameterMeta;
 import org.apache.ignite.internal.processors.query.GridQueryCancel;
 import org.apache.ignite.internal.processors.query.GridQueryFieldMetadata;
@@ -56,6 +59,7 @@ import org.apache.ignite.internal.processors.query.QueryIndexDescriptorImpl;
 import org.apache.ignite.internal.processors.query.SqlClientContext;
 import org.apache.ignite.internal.processors.query.UpdateSourceIterator;
 import org.apache.ignite.internal.processors.query.schema.SchemaIndexCacheVisitor;
+import org.apache.ignite.internal.util.GridAtomicLong;
 import org.apache.ignite.internal.util.GridSpinBusyLock;
 import org.apache.ignite.internal.util.lang.GridCloseableIterator;
 import org.apache.ignite.lang.IgniteBiTuple;
@@ -327,6 +331,12 @@ public class IgniteClientCacheInitializationFailTest extends GridCommonAbstractT
         }
 
         /** {@inheritDoc} */
+        @Override public void destroyOrphanIndex(RootPage page, String indexName, int grpId, PageMemory pageMemory,
+            GridAtomicLong removeId, ReuseList reuseList, boolean mvccEnabled) throws IgniteCheckedException {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
         @Override public void dynamicAddColumn(String schemaName, String tblName, List<QueryField> cols,
                                                boolean ifTblExists, boolean ifColNotExists)
             throws IgniteCheckedException {
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
index d30a2d6..09d2a39 100755
--- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
@@ -1393,7 +1393,7 @@ public abstract class GridAbstractTest extends JUnitAssertAware {
      * @param idx Index.
      * @return Ignite instance.
      */
-    protected Ignite ignite(int idx) {
+    protected IgniteEx ignite(int idx) {
         return grid(idx);
     }
 
diff --git a/modules/core/src/test/java/org/apache/ignite/util/GridCommandHandlerTest.java b/modules/core/src/test/java/org/apache/ignite/util/GridCommandHandlerTest.java
index 8d49622..b953fa7 100644
--- a/modules/core/src/test/java/org/apache/ignite/util/GridCommandHandlerTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/util/GridCommandHandlerTest.java
@@ -28,6 +28,7 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
@@ -224,7 +225,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
 
     /** {@inheritDoc} */
     @Override public String getTestIgniteInstanceName() {
-        return "bltTest";
+        return "gridCommandHandlerTest";
     }
 
     /** {@inheritDoc} */
@@ -435,6 +436,42 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
     }
 
     /**
+     * Very basic tests for running the command in different enviroment which other command are running in.
+     *
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testFindAndDeleteGarbage() throws Exception {
+        Ignite ignite = startGrids(2);
+
+        ignite.cluster().active(true);
+
+        injectTestSystemOut();
+
+        ignite.createCaches(Arrays.asList(
+            new CacheConfiguration<>("garbage1").setGroupName("groupGarbage"),
+            new CacheConfiguration<>("garbage2").setGroupName("groupGarbage")));
+
+        assertEquals(EXIT_CODE_OK, execute("--cache", "find_garbage", "--port", "11212"));
+
+        assertTrue(testOut.toString().contains("garbage not found"));
+
+        testOut.reset();
+
+        assertEquals(EXIT_CODE_OK, execute("--cache", "find_garbage",
+            ignite(0).localNode().id().toString(), "--port", "11212"));
+
+        assertTrue(testOut.toString().contains("garbage not found"));
+
+        testOut.reset();
+
+        assertEquals(EXIT_CODE_OK, execute("--cache", "find_garbage",
+            "groupGarbage", "--port", "11212"));
+
+        assertTrue(testOut.toString().contains("garbage not found"));
+    }
+
+    /**
      * @return utility information about coordinator
      */
     private String findCrdInfo() {
@@ -735,7 +772,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
         CountDownLatch lockLatch = new CountDownLatch(1);
         CountDownLatch unlockLatch = new CountDownLatch(1);
 
-        IgniteInternalFuture<?> fut = startTransactions(lockLatch, unlockLatch, true);
+        IgniteInternalFuture<?> fut = startTransactions("testActiveTransactions", lockLatch, unlockLatch, true);
 
         U.awaitQuiet(lockLatch);
 
@@ -893,36 +930,39 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
         CountDownLatch lockLatch = new CountDownLatch(1);
         CountDownLatch unlockLatch = new CountDownLatch(1);
 
-        IgniteInternalFuture<?> fut = startTransactions(lockLatch, unlockLatch, false);
+        IgniteInternalFuture<?> fut = startTransactions("testTransactionInfo", lockLatch, unlockLatch, false);
 
-        U.awaitQuiet(lockLatch);
-
-        doSleep(3000); // Should be more than enough for all transactions to appear in contexts.
+        try {
+            U.awaitQuiet(lockLatch);
 
-        Set<GridCacheVersion> nearXids = new HashSet<>();
+            doSleep(3000); // Should be more than enough for all transactions to appear in contexts.
 
-        for (int i = 0; i < 5; i++) {
-            IgniteEx grid = grid(i);
+            Set<GridCacheVersion> nearXids = new HashSet<>();
 
-            IgniteTxManager tm = grid.context().cache().context().tm();
+            for (int i = 0; i < 5; i++) {
+                IgniteEx grid = grid(i);
 
-            for (IgniteInternalTx tx : tm.activeTransactions())
-                nearXids.add(tx.nearXidVersion());
-        }
+                IgniteTxManager tm = grid.context().cache().context().tm();
 
-        injectTestSystemOut();
+                for (IgniteInternalTx tx : tm.activeTransactions())
+                    nearXids.add(tx.nearXidVersion());
+            }
 
-        for (GridCacheVersion nearXid : nearXids)
-            assertEquals(EXIT_CODE_OK, execute("--tx", "--info", nearXid.toString()));
+            injectTestSystemOut();
 
-        String out = testOut.toString();
+            for (GridCacheVersion nearXid : nearXids)
+                assertEquals(EXIT_CODE_OK, execute("--tx", "--info", nearXid.toString()));
 
-        for (GridCacheVersion nearXid : nearXids)
-            assertTrue(out.contains(nearXid.toString()));
+            String out = testOut.toString();
 
-        unlockLatch.countDown();
+            for (GridCacheVersion nearXid : nearXids)
+                assertTrue(nearXid.toString(), out.contains(nearXid.toString()));
+        }
+        finally {
+            unlockLatch.countDown();
 
-        fut.get();
+            fut.get();
+        }
     }
 
     /**
@@ -945,7 +985,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
         CountDownLatch lockLatch = new CountDownLatch(1);
         CountDownLatch unlockLatch = new CountDownLatch(1);
 
-        IgniteInternalFuture<?> fut = startTransactions(lockLatch, unlockLatch, false);
+        IgniteInternalFuture<?> fut = startTransactions("testTransactionHistoryInfo", lockLatch, unlockLatch, false);
 
         U.awaitQuiet(lockLatch);
 
@@ -1166,8 +1206,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
                 if (m instanceof GridDhtTxFinishRequest) {
                     GridDhtTxFinishRequest r = (GridDhtTxFinishRequest)m;
 
-                    if (r.nearNodeId().equals(clients[0].cluster().localNode().id()))
-                        return false;
+                    return !r.nearNodeId().equals(clients[0].cluster().localNode().id());
                 }
 
                 return true;
@@ -1273,7 +1312,8 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
 
         assertEquals(EXIT_CODE_UNEXPECTED_ERROR, execute("--baseline", "add", consistentIDs));
 
-        assertTrue(testOut.toString().contains("Node not found for consistent ID: bltTest2"));
+        assertTrue(testOut.toString(), testOut.toString().contains("Node not found for consistent ID:"));
+        assertFalse(testOut.toString(), testOut.toString().contains(getTestIgniteInstanceName() + "1"));
     }
 
     /**
@@ -1776,9 +1816,8 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
 
         injectTestSystemOut();
 
-        IgniteInternalFuture fut = GridTestUtils.runAsync(() -> {
-            assertEquals(EXIT_CODE_OK, execute("--cache", "idle_verify", "--dump"));
-        });
+        IgniteInternalFuture fut = GridTestUtils.runAsync(() ->
+            assertEquals(EXIT_CODE_OK, execute("--cache", "idle_verify", "--dump")));
 
         TestRecordingCommunicationSpi.spi(unstable).waitForBlocked();
 
@@ -1869,8 +1908,8 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
 
         String outputStr = testOut.toString();
 
-        assertTrue(outputStr.contains("idle_verify failed on 1 node."));
-        assertTrue(outputStr.contains("idle_verify check has finished, no conflicts have been found."));
+        assertTrue(outputStr, outputStr.contains("idle_verify failed on 1 node."));
+        assertTrue(outputStr, outputStr.contains("idle_verify check has finished, no conflicts have been found."));
     }
 
     /** */
@@ -1968,7 +2007,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
             .setAffinity(new RendezvousAffinityFunction(false, parts))
             .setBackups(2);
 
-        IgniteEx ignite = (IgniteEx)startGrids(3);
+        IgniteEx ignite = startGrids(3);
 
         ignite.cluster().active(true);
 
@@ -2023,7 +2062,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
      */
     @Test
     public void testCacheIdleVerifyDumpForCorruptedDataOnPersistenceClientCache() throws Exception {
-        IgniteEx ignite = (IgniteEx)startGrids(3);
+        IgniteEx ignite = startGrids(3);
 
         ignite.cluster().active(true);
 
@@ -2044,7 +2083,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
         dataRegionConfiguration = new DataRegionConfiguration()
             .setName("none-persistence-region");
 
-        IgniteEx ignite = (IgniteEx)startGrids(3);
+        IgniteEx ignite = startGrids(3);
 
         ignite.cluster().active(true);
 
@@ -2090,7 +2129,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
      */
     @Test
     public void testCacheIdleVerifyDumpExcludedCacheGrp() throws Exception {
-        IgniteEx ignite = (IgniteEx)startGrids(3);
+        IgniteEx ignite = startGrids(3);
 
         ignite.cluster().active(true);
 
@@ -2130,7 +2169,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
      */
     @Test
     public void testCacheIdleVerifyDumpExcludedCaches() throws Exception {
-        IgniteEx ignite = (IgniteEx)startGrids(3);
+        IgniteEx ignite = startGrids(3);
 
         ignite.cluster().active(true);
 
@@ -2185,7 +2224,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
      */
     @Test
     public void testCacheIdleVerifyMovingParts() throws Exception {
-        IgniteEx ignite = (IgniteEx)startGrids(2);
+        IgniteEx ignite = startGrids(2);
 
         ignite.cluster().active(true);
 
@@ -2649,6 +2688,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
      * @return Future to be completed after finish of all started transactions.
      */
     private IgniteInternalFuture<?> startTransactions(
+        String testName,
         CountDownLatch lockLatch,
         CountDownLatch unlockLatch,
         boolean topChangeBeforeUnlock
@@ -2717,7 +2757,7 @@ public class GridCommandHandlerTest extends GridCommonAbstractTest {
                         break;
                 }
             }
-        }, 4, "tx-thread");
+        }, 4, "tx-thread-" + testName);
     }
 
     /** */
diff --git a/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java b/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
index 02d00b8..10f71c2 100644
--- a/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
+++ b/modules/indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/IgniteH2Indexing.java
@@ -55,6 +55,7 @@ import org.apache.ignite.internal.managers.communication.GridMessageListener;
 import org.apache.ignite.internal.managers.eventstorage.GridLocalEventListener;
 import org.apache.ignite.internal.mxbean.SqlQueryMXBean;
 import org.apache.ignite.internal.mxbean.SqlQueryMXBeanImpl;
+import org.apache.ignite.internal.pagemem.PageMemory;
 import org.apache.ignite.internal.pagemem.store.IgnitePageStoreManager;
 import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
 import org.apache.ignite.internal.processors.cache.CacheObjectValueContext;
@@ -71,7 +72,12 @@ import org.apache.ignite.internal.processors.cache.mvcc.MvccSnapshot;
 import org.apache.ignite.internal.processors.cache.mvcc.MvccUtils;
 import org.apache.ignite.internal.processors.cache.mvcc.StaticMvccQueryTracker;
 import org.apache.ignite.internal.processors.cache.persistence.CacheDataRow;
+import org.apache.ignite.internal.processors.cache.persistence.RootPage;
+import org.apache.ignite.internal.processors.cache.persistence.tree.BPlusTree;
+import org.apache.ignite.internal.processors.cache.persistence.tree.io.BPlusIO;
+import org.apache.ignite.internal.processors.cache.persistence.tree.io.BPlusMetaIO;
 import org.apache.ignite.internal.processors.cache.persistence.tree.io.PageIO;
+import org.apache.ignite.internal.processors.cache.persistence.tree.reuse.ReuseList;
 import org.apache.ignite.internal.processors.cache.query.GridCacheQueryMarshallable;
 import org.apache.ignite.internal.processors.cache.query.GridCacheQueryType;
 import org.apache.ignite.internal.processors.cache.query.GridCacheTwoStepQuery;
@@ -116,6 +122,7 @@ import org.apache.ignite.internal.processors.query.h2.dml.UpdateMode;
 import org.apache.ignite.internal.processors.query.h2.dml.UpdatePlan;
 import org.apache.ignite.internal.processors.query.h2.opt.GridH2IndexBase;
 import org.apache.ignite.internal.processors.query.h2.opt.GridH2Table;
+import org.apache.ignite.internal.processors.query.h2.opt.H2Row;
 import org.apache.ignite.internal.processors.query.h2.opt.QueryContext;
 import org.apache.ignite.internal.processors.query.h2.opt.QueryContextRegistry;
 import org.apache.ignite.internal.processors.query.h2.sql.GridSqlStatement;
@@ -136,6 +143,7 @@ import org.apache.ignite.internal.sql.command.SqlCommand;
 import org.apache.ignite.internal.sql.command.SqlCommitTransactionCommand;
 import org.apache.ignite.internal.sql.command.SqlRollbackTransactionCommand;
 import org.apache.ignite.internal.sql.optimizer.affinity.PartitionResult;
+import org.apache.ignite.internal.util.GridAtomicLong;
 import org.apache.ignite.internal.util.GridEmptyCloseableIterator;
 import org.apache.ignite.internal.util.GridSpinBusyLock;
 import org.apache.ignite.internal.util.IgniteUtils;
@@ -2197,6 +2205,78 @@ public class IgniteH2Indexing implements GridQueryIndexing {
         clearPlanCache();
     }
 
+    /** {@inheritDoc} */
+    @Override public void destroyOrphanIndex(
+        RootPage page,
+        String indexName,
+        int grpId,
+        PageMemory pageMemory,
+        final GridAtomicLong removeId,
+        final ReuseList reuseList,
+        boolean mvccEnabled
+    ) throws IgniteCheckedException {
+        assert ctx.cache().context().database().checkpointLockIsHeldByThread();
+
+        long metaPageId = page.pageId().pageId();
+
+        int inlineSize = getInlineSize(page, grpId, pageMemory);
+
+        BPlusTree<H2Row, H2Row> tree = new BPlusTree<H2Row, H2Row>(
+            indexName,
+            grpId,
+            pageMemory,
+            ctx.cache().context().wal(),
+            removeId,
+            metaPageId,
+            reuseList,
+            H2ExtrasInnerIO.getVersions(inlineSize, mvccEnabled),
+            H2ExtrasLeafIO.getVersions(inlineSize, mvccEnabled),
+            ctx.failure()
+        ) {
+            @Override protected int compare(BPlusIO io, long pageAddr, int idx, H2Row row) {
+                throw new AssertionError();
+            }
+
+            @Override public H2Row getRow(BPlusIO io, long pageAddr, int idx, Object x) {
+                throw new AssertionError();
+            }
+        };
+
+        tree.destroy();
+    }
+
+    /**
+     * @param page Root page.
+     * @param grpId Cache group id.
+     * @param pageMemory Page memory.
+     * @return Inline size.
+     * @throws IgniteCheckedException If something went wrong.
+     */
+    private int getInlineSize(RootPage page, int grpId, PageMemory pageMemory) throws IgniteCheckedException {
+        long metaPageId = page.pageId().pageId();
+
+        final long metaPage = pageMemory.acquirePage(grpId, metaPageId);
+
+        try {
+            long pageAddr = pageMemory.readLock(grpId, metaPageId, metaPage); // Meta can't be removed.
+
+            assert pageAddr != 0 : "Failed to read lock meta page [metaPageId=" +
+                U.hexLong(metaPageId) + ']';
+
+            try {
+                BPlusMetaIO io = BPlusMetaIO.VERSIONS.forPage(pageAddr);
+
+                return io.getInlineSize(pageAddr);
+            }
+            finally {
+                pageMemory.readUnlock(grpId, metaPageId, metaPage);
+            }
+        }
+        finally {
+            pageMemory.releasePage(grpId, metaPageId, metaPage);
+        }
+    }
+
     /**
      * Remove all cached queries from cached two-steps queries.
      */
diff --git a/modules/indexing/src/test/java/org/apache/ignite/client/IgniteBinaryQueryTest.java b/modules/indexing/src/test/java/org/apache/ignite/client/IgniteBinaryQueryTest.java
index a524394..d470de4 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/client/IgniteBinaryQueryTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/client/IgniteBinaryQueryTest.java
@@ -33,10 +33,6 @@ import org.apache.ignite.binary.BinaryType;
 import org.apache.ignite.cache.QueryEntity;
 import org.apache.ignite.cache.QueryIndex;
 import org.apache.ignite.cache.query.SqlQuery;
-import org.apache.ignite.client.ClientCache;
-import org.apache.ignite.client.ClientCacheConfiguration;
-import org.apache.ignite.client.Config;
-import org.apache.ignite.client.IgniteClient;
 import org.apache.ignite.configuration.ClientConfiguration;
 import org.apache.ignite.testframework.GridTestUtils;
 import org.junit.Rule;
diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/persistence/db/IgniteCacheGroupsWithRestartsTest.java b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/persistence/db/IgniteCacheGroupsWithRestartsTest.java
new file mode 100644
index 0000000..1f940a7
--- /dev/null
+++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/persistence/db/IgniteCacheGroupsWithRestartsTest.java
@@ -0,0 +1,313 @@
+/*
+ * 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.persistence.db;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.function.BiFunction;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.cache.QueryEntity;
+import org.apache.ignite.cache.QueryIndex;
+import org.apache.ignite.cache.QueryIndexType;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.ConnectorConfiguration;
+import org.apache.ignite.configuration.DataRegionConfiguration;
+import org.apache.ignite.configuration.DataStorageConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.commandline.CommandHandler;
+import org.apache.ignite.internal.commandline.cache.argument.FindAndDeleteGarbageArg;
+import org.apache.ignite.internal.util.typedef.internal.CU;
+import org.apache.ignite.internal.util.typedef.internal.S;
+import org.apache.ignite.internal.visor.VisorTaskArgument;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceJobResult;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTask;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTaskArg;
+import org.apache.ignite.internal.visor.cache.VisorFindAndDeleteGarbageInPersistenceTaskResult;
+import org.apache.ignite.testframework.junits.WithSystemProperty;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.apache.ignite.testframework.junits.multijvm.IgniteProcessProxy;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.apache.ignite.internal.processors.cache.persistence.GridCacheDatabaseSharedManager.IGNITE_PDS_SKIP_CHECKPOINT_ON_NODE_STOP;
+
+/**
+ * Testing corner cases in cache group functionality:
+ * -stopping cache in shared group and immediate node leaving;
+ * -starting cache in shared group with the same name as destroyed one;
+ * -etc.
+ */
+@WithSystemProperty(key=IGNITE_PDS_SKIP_CHECKPOINT_ON_NODE_STOP, value="true")
+@SuppressWarnings({"unchecked", "ThrowableNotThrown"})
+public class IgniteCacheGroupsWithRestartsTest extends GridCommonAbstractTest {
+    /** Group name. */
+    public static final String GROUP = "group";
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
+        IgniteConfiguration configuration = super.getConfiguration(gridName);
+
+        configuration.setConnectorConfiguration(new ConnectorConfiguration());
+
+        DataStorageConfiguration cfg = new DataStorageConfiguration();
+
+        cfg.setDefaultDataRegionConfiguration(new DataRegionConfiguration()
+            .setPersistenceEnabled(true)
+            .setMaxSize(256 * 1024 * 1024));
+
+        configuration.setDataStorageConfiguration(cfg);
+
+        return configuration;
+    }
+
+    /**
+     * @param i Cache index number.
+     * @return Cache configuration with the given number in name.
+     */
+    private CacheConfiguration<Object, Object> getCacheConfiguration(int i) {
+        CacheConfiguration ccfg = new CacheConfiguration();
+
+        LinkedHashMap<String, String> fields = new LinkedHashMap<>();
+
+        fields.put("updateDate", "java.lang.Date");
+        fields.put("amount", "java.lang.Long");
+        fields.put("name", "java.lang.String");
+
+        Set<QueryIndex> indices = Collections.singleton(new QueryIndex("name", QueryIndexType.SORTED));
+
+        ccfg.setName(getCacheName(i))
+            .setGroupName("group")
+            .setQueryEntities(Collections.singletonList(
+                new QueryEntity(Long.class, Account.class)
+                    .setFields(fields)
+                    .setIndexes(indices)
+            ))
+            .setAffinity(new RendezvousAffinityFunction(false, 64));
+
+        return ccfg;
+    }
+
+    /**
+     * @param i Index.
+     * @return Generated cache name for index.
+     */
+    private String getCacheName(int i) {
+        return "cache-" + i;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTest() throws Exception {
+        afterTest();
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTest() throws Exception {
+        super.afterTest();
+
+        stopAllGrids();
+
+        cleanPersistenceDir();
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    @Ignore("https://issues.apache.org/jira/browse/IGNITE-8717")
+    @Test
+    public void testNodeRestartRightAfterCacheStop() throws Exception {
+        IgniteEx ex = startGrids(3);
+
+        prepareCachesAndData(ex);
+
+        ex.destroyCache(getCacheName(0));
+
+        assertNull(ex.cachex(getCacheName(0)));
+
+        IgniteProcessProxy.kill(grid(2).configuration().getIgniteInstanceName());
+
+        startGrid(2);
+
+        assertNull(ex.cachex(getCacheName(0)));
+
+        IgniteCache<Object, Object> cache = ex.createCache(getCacheConfiguration(0));
+
+        awaitPartitionMapExchange();
+
+        assertEquals(0, cache.size());
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testDeletingGarbageAfterCacheDestroyedAndNodeStop() throws Exception {
+        testFindAndDeleteGarbage(this::executeTask);
+    }
+
+
+    /**
+     * @throws Exception If failed.
+     */
+    @Test
+    public void testDeletingGarbageAfterCacheDestroyedAndNodeStop_ControlConsoleUtil() throws Exception {
+        testFindAndDeleteGarbage(this::executeTaskViaControlConsoleUtil);
+    }
+
+    /**
+     * @param doFindAndRemove Do find and remove.
+     */
+    private void testFindAndDeleteGarbage(
+        BiFunction<IgniteEx, Boolean, VisorFindAndDeleteGarbageInPersistenceTaskResult> doFindAndRemove
+    ) throws Exception {
+        IgniteEx ignite = startGrids(3);
+
+        prepareCachesAndData(ignite);
+
+        ignite.destroyCache(getCacheName(0));
+
+        assertNull(ignite.cachex(getCacheName(0)));
+
+        Thread.sleep(5_000); // waiting for cache.dat deletion
+
+        stopGrid(2, true);
+
+        IgniteEx ex1 = startGrid(2);
+
+        assertNull(ignite.cachex(getCacheName(0)));
+
+        awaitPartitionMapExchange();
+
+        VisorFindAndDeleteGarbageInPersistenceTaskResult taskResult = doFindAndRemove.apply(ex1, false);
+
+        VisorFindAndDeleteGarbageInPersistenceJobResult result = taskResult.result().get(ex1.localNode().id());
+
+        Assert.assertTrue(result.hasGarbage());
+
+        Assert.assertTrue(result.checkResult()
+            .get(CU.cacheId("group"))
+            .get(CU.cacheId(getCacheName(0))) > 0);
+
+        //removing garbage
+        result = doFindAndRemove.apply(ex1, true).result().get(ex1.localNode().id());
+
+        Assert.assertTrue(result.hasGarbage());
+
+        result = doFindAndRemove.apply(ex1, false).result().get(ex1.localNode().id());
+
+        Assert.assertFalse(result.hasGarbage());
+    }
+
+    /**
+     * @param ignite Ignite to execute task on.
+     * @param deleteFoundGarbage If clearing mode should be used.
+     * @return Result of task run.
+     */
+    private VisorFindAndDeleteGarbageInPersistenceTaskResult executeTask(
+        IgniteEx ignite,
+        boolean deleteFoundGarbage
+    ) {
+        VisorFindAndDeleteGarbageInPersistenceTaskArg group = new VisorFindAndDeleteGarbageInPersistenceTaskArg(
+            Collections.singleton(GROUP), deleteFoundGarbage, null);
+
+        UUID id = ignite.localNode().id();
+
+        VisorTaskArgument arg = new VisorTaskArgument(id, group, true);
+
+        VisorFindAndDeleteGarbageInPersistenceTaskResult result =
+            ignite.compute().execute(VisorFindAndDeleteGarbageInPersistenceTask.class, arg);
+
+        return result;
+    }
+
+    /**
+     * @param ignite Ignite to execute task on.
+     * @param deleteFoundGarbage If clearing mode should be used.
+     * @return Result of task run.
+     */
+    private VisorFindAndDeleteGarbageInPersistenceTaskResult executeTaskViaControlConsoleUtil(
+        IgniteEx ignite,
+        boolean deleteFoundGarbage
+    ) {
+        CommandHandler handler = new CommandHandler();
+
+        List<String> args = new ArrayList<>(Arrays.asList("--yes", "--port", "11212", "--cache", "find_garbage",
+            ignite.localNode().id().toString()));
+
+        if (deleteFoundGarbage)
+            args.add(FindAndDeleteGarbageArg.DELETE.argName());
+
+        handler.execute(args);
+
+        return handler.getLastOperationResult();
+    }
+
+    /**
+     * @param ignite Ignite instance.
+     */
+    private void prepareCachesAndData(IgniteEx ignite) {
+        ignite.cluster().active(true);
+
+        for (int j = 0; j < 3; j++) {
+            for (int i = 0; i < 64 * 10; i++) {
+                IgniteCache<Object, Object> cache = ignite.getOrCreateCache(getCacheConfiguration(j));
+
+                byte[] val = new byte[ThreadLocalRandom.current().nextInt(8148)];
+
+                Arrays.fill(val, (byte)i);
+
+                cache.put((long)i, new Account(i));
+            }
+        }
+    }
+
+    /**
+     *
+     */
+    static class Account {
+        /** */
+        private final int val;
+
+        /**
+         * @param val Value.
+         */
+        public Account(int val) {
+            this.val = val;
+        }
+
+        /**
+         * @return Value.
+         */
+        public int value() {
+            return val;
+        }
+
+        /** {@inheritDoc} */
+        @Override public String toString() {
+            return S.toString(Account.class, this);
+        }
+    }
+}
diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/h2/GridIndexFullRebuildTest.java b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/h2/GridIndexFullRebuildTest.java
index 2facb65..02fca0f 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/h2/GridIndexFullRebuildTest.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/h2/GridIndexFullRebuildTest.java
@@ -209,7 +209,7 @@ public class GridIndexFullRebuildTest extends GridCommonAbstractTest {
 
         VisorTaskArgument<VisorValidateIndexesTaskArg> argument = new VisorTaskArgument<>(nodes, arg, true);
 
-        ComputeTaskInternalFuture<VisorValidateIndexesTaskResult> execute = ((IgniteEx)grid1).context().task().execute(new VisorValidateIndexesTask(), argument);
+        ComputeTaskInternalFuture<VisorValidateIndexesTaskResult> execute = grid1.context().task().execute(new VisorValidateIndexesTask(), argument);
 
         VisorValidateIndexesTaskResult result = execute.get();
 
diff --git a/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java b/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
index e52f7ec..539f5aa 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
@@ -26,6 +26,7 @@ import org.apache.ignite.internal.processors.cache.persistence.IgnitePdsTxCacheR
 import org.apache.ignite.internal.processors.cache.persistence.IgnitePdsTxHistoricalRebalancingTest;
 import org.apache.ignite.internal.processors.cache.persistence.IgnitePersistentStoreCacheGroupsTest;
 import org.apache.ignite.internal.processors.cache.persistence.PersistenceDirectoryWarningLoggingTest;
+import org.apache.ignite.internal.processors.cache.persistence.db.IgniteCacheGroupsWithRestartsTest;
 import org.apache.ignite.internal.processors.cache.persistence.db.IgniteLogicalRecoveryTest;
 import org.apache.ignite.internal.processors.cache.persistence.db.IgnitePdsMultiNodePutGetRestartTest;
 import org.apache.ignite.internal.processors.cache.persistence.db.IgnitePdsPageEvictionTest;
@@ -87,7 +88,9 @@ import org.junit.runners.Suite;
 
     IgniteLogicalRecoveryTest.class,
 
-    IgniteSequentialNodeCrashRecoveryTest.class
+    IgniteSequentialNodeCrashRecoveryTest.class,
+
+    IgniteCacheGroupsWithRestartsTest.class
 })
 public class IgnitePdsWithIndexingCoreTestSuite {
 }