support cache groups in change WAL methods

Author: VolkodamovDaniil

modules/control-utility/src/test/java/org/apache/ignite/util/GridCommandHandlerWalTest.java

@@ -17,7 +17,6 @@
 
 package org.apache.ignite.util;
 
-import java.util.Arrays;
 import java.util.Objects;
 import java.util.regex.Pattern;
 import org.apache.ignite.cluster.ClusterState;
@@ -192,24 +191,15 @@ public void testWalChangeForMultiCacheGroup() throws Exception {
         assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "testGroup"));
         outputContains(".*testGroup.*true.*true.*true.*true.*false");
 
-        // disableWal fails, but EXIT_CODE_OK
         assertEquals(EXIT_CODE_OK, execute("--wal", "disable", "--groups", "testGroup"));
 
-        // WAL is still enabled
-        assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "testGroup"));
-        outputContains(".*testGroup.*true.*true.*true.*true.*false");
-
-        srv.cluster().disableWal(Arrays.asList("cache1", "cache2"));
-
         assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "testGroup"));
         outputContains(".*testGroup.*true.*false.*true.*true.*false");
 
-        // enableWal fails
-        assertEquals(EXIT_CODE_OK, execute("--wal", "disable", "--groups", "testGroup"));
+        assertEquals(EXIT_CODE_OK, execute("--wal", "enable", "--groups", "testGroup"));
 
-        // WAL is still disabled
         assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "testGroup"));
-        outputContains(".*testGroup.*true.*false.*true.*true.*false");
+        outputContains(".*testGroup.*true.*true.*true.*true.*false");
     }
 
     /** */

modules/core/src/main/java/org/apache/ignite/IgniteCluster.java

@@ -536,38 +536,13 @@ public IgniteFuture<Collection<ClusterStartNodeResult>> startNodesAsync(Collecti
      * Cache may be stuck in inconsistent state due to violation of these conditions. It is advised to destroy
      * such cache.
      *
-     * @param cacheName Cache name.
+     * @param cacheOrGrpName Cache or cache group name.
      * @return Whether WAL disabled by this call.
      * @throws IgniteException If error occurs.
      * @see #enableWal(String)
      * @see #isWalEnabled(String)
      */
-    public boolean disableWal(String cacheName) throws IgniteException;
-
-    /**
-     * Disables write-ahead logging for specified caches. When WAL is disabled, changes are not logged to disk.
-     * This significantly improves cache update speed. The drawback is absence of local crash-recovery guarantees.
-     * If node is crashed, local content of WAL-disabled cache will be cleared on restart to avoid data corruption.
-     * <p>
-     * Internally this method will wait for all current cache operations to finish and prevent new cache operations
-     * from being executed. Then checkpoint is initiated to flush all data to disk. Control is returned to the callee
-     * when all dirty pages are prepared for checkpoint, but not necessarily flushed to disk.
-     * <p>
-     * WAL state can be changed only for persistent caches.
-     * <p>
-     * <b>NOTE:</b>
-     * Currently, this method should only be called on a stable topology when no nodes are leaving or joining cluster,
-     * and all baseline nodes are present.
-     * Cache may be stuck in inconsistent state due to violation of these conditions. It is advised to destroy
-     * such cache.
-     *
-     * @param cacheNames Collection of cache names, all caches must be in the same cache group.
-     * @return Whether WAL disabled by this call.
-     * @throws IgniteException If error occurs.
-     * @see #enableWal(Collection)
-     * @see #isWalEnabled(String)
-     */
-    public boolean disableWal(Collection<String> cacheNames) throws IgniteException;
+    public boolean disableWal(String cacheOrGrpName) throws IgniteException;
 
     /**
      * Enables write-ahead logging for specified cache. Restoring crash-recovery guarantees of a previous call to
@@ -585,37 +560,13 @@ public IgniteFuture<Collection<ClusterStartNodeResult>> startNodesAsync(Collecti
      * Cache may be stuck in inconsistent state due to violation of these conditions. It is advised to destroy
      * such cache.
      *
-     * @param cacheName Cache name.
+     * @param cacheOrGrpName Cache or cache group name.
      * @return Whether WAL enabled by this call.
      * @throws IgniteException If error occurs.
      * @see #disableWal(String)
      * @see #isWalEnabled(String)
      */
-    public boolean enableWal(String cacheName) throws IgniteException;
-
-    /**
-     * Enables write-ahead logging for specified caches. Restoring crash-recovery guarantees of a previous call to
-     * {@link #disableWal(Collection)}.
-     * <p>
-     * Internally this method will wait for all current cache operations to finish and prevent new cache operations
-     * from being executed. Then checkpoint is initiated to flush all data to disk. Control is returned to the callee
-     * when all data is persisted to disk.
-     * <p>
-     * WAL state can be changed only for persistent caches.
-     * <p>
-     * <b>NOTE:</b>
-     * Currently, this method should only be called on a stable topology when no nodes are leaving or joining cluster,
-     * and all baseline nodes are present.
-     * Cache may be stuck in inconsistent state due to violation of these conditions. It is advised to destroy
-     * such cache.
-     *
-     * @param cacheNames Collection of cache names, all caches must be in the same cache group.
-     * @return Whether WAL state enabled by this call.
-     * @throws IgniteException If error occurs.
-     * @see #disableWal(Collection)
-     * @see #isWalEnabled(String)
-     */
-    public boolean enableWal(Collection<String> cacheNames) throws IgniteException;
+    public boolean enableWal(String cacheOrGrpName) throws IgniteException;
 
     /**
      * Checks if write-ahead logging is enabled for specified cache.

modules/core/src/main/java/org/apache/ignite/internal/cluster/IgniteClusterAsyncImpl.java

@@ -345,23 +345,13 @@ public IgniteClusterAsyncImpl(IgniteClusterImpl cluster) {
     }
 
     /** {@inheritDoc} */
-    @Override public boolean enableWal(String cacheName) throws IgniteException {
-        return cluster.enableWal(cacheName);
+    @Override public boolean enableWal(String cacheOrGrpName) throws IgniteException {
+        return cluster.enableWal(cacheOrGrpName);
     }
 
     /** {@inheritDoc} */
-    @Override public boolean enableWal(Collection<String> cacheNames) throws IgniteException {
-        return cluster.enableWal(cacheNames);
-    }
-
-    /** {@inheritDoc} */
-    @Override public boolean disableWal(String cacheName) throws IgniteException {
-        return cluster.disableWal(cacheName);
-    }
-
-    /** {@inheritDoc} */
-    @Override public boolean disableWal(Collection<String> cacheNames) throws IgniteException {
-        return cluster.disableWal(cacheNames);
+    @Override public boolean disableWal(String cacheOrGrpName) throws IgniteException {
+        return cluster.disableWal(cacheOrGrpName);
     }
 
     /** {@inheritDoc} */

modules/core/src/main/java/org/apache/ignite/internal/cluster/IgniteClusterImpl.java

@@ -52,6 +52,7 @@
 import org.apache.ignite.internal.GridKernalContext;
 import org.apache.ignite.internal.IgniteComponentType;
 import org.apache.ignite.internal.IgniteInternalFuture;
+import org.apache.ignite.internal.processors.cache.CacheGroupDescriptor;
 import org.apache.ignite.internal.processors.cache.DynamicCacheDescriptor;
 import org.apache.ignite.internal.processors.cluster.BaselineTopology;
 import org.apache.ignite.internal.processors.cluster.baseline.autoadjust.BaselineAutoAdjustStatus;
@@ -631,40 +632,41 @@ private void setBaselineTopology(long topVer, boolean isBaselineAutoAdjust) {
     }
 
     /** {@inheritDoc} */
-    @Override public boolean enableWal(String cacheName) throws IgniteException {
-        return changeWalMode(Collections.singleton(cacheName), true);
+    @Override public boolean enableWal(String cacheOrGrpName) throws IgniteException {
+        return changeWalMode(cacheOrGrpName, true);
     }
 
     /** {@inheritDoc} */
-    @Override public boolean enableWal(Collection<String> cacheNames) throws IgniteException {
-        return changeWalMode(cacheNames, true);
-    }
-
-    /** {@inheritDoc} */
-    @Override public boolean disableWal(String cacheName) throws IgniteException {
-        return changeWalMode(Collections.singleton(cacheName), false);
-    }
-
-    /** {@inheritDoc} */
-    @Override public boolean disableWal(Collection<String> cacheNames) throws IgniteException {
-        return changeWalMode(cacheNames, false);
+    @Override public boolean disableWal(String cacheOrGrpName) throws IgniteException {
+        return changeWalMode(cacheOrGrpName, false);
     }
 
     /**
      * Change WAL mode.
      *
-     * @param cacheNames Cache names.
+     * @param cacheOrGrpName Cache or cache group name.
      * @param enabled Enabled flag.
      * @return {@code True} if WAL mode was changed as a result of this call.
      */
-    private boolean changeWalMode(Collection<String> cacheNames, boolean enabled) {
-        A.notNull(cacheNames, "cacheNames");
-
-        if (cacheNames.isEmpty())
-            return false;
+    private boolean changeWalMode(String cacheOrGrpName, boolean enabled) {
+        A.notNull(cacheOrGrpName, "cacheOrGrpName");
 
         guard();
 
+        List<String> cacheNames = new ArrayList<>();
+
+        int cacheOrGrpId = CU.cacheId(cacheOrGrpName);
+        CacheGroupDescriptor grpDesc = ctx.cache().cacheGroupDescriptor(cacheOrGrpId);
+
+        if (grpDesc != null) {
+            for (DynamicCacheDescriptor cacheDesc : ctx.cache().cacheDescriptors().values()) {
+                if (cacheDesc.groupId() == cacheOrGrpId)
+                    cacheNames.add(cacheDesc.cacheName());
+            }
+        }
+        else
+            cacheNames.add(cacheOrGrpName);
+
         try {
             return ctx.cache().context().walState().changeWalMode(cacheNames, enabled).get();
         }

modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalSetStateTask.java

@@ -26,7 +26,6 @@
 import org.apache.ignite.internal.management.wal.WalDisableCommand.WalDisableCommandArg;
 import org.apache.ignite.internal.management.wal.WalEnableCommand.WalEnableCommandArg;
 import org.apache.ignite.internal.processors.cache.CacheGroupContext;
-import org.apache.ignite.internal.processors.cache.GridCacheContext;
 import org.apache.ignite.internal.util.typedef.F;
 import org.apache.ignite.internal.visor.VisorJob;
 import org.apache.ignite.internal.visor.VisorMultiNodeTask;
@@ -67,15 +66,10 @@ protected WalDisableJob(@Nullable WalDisableCommandArg arg, boolean debug) {
                 if (grps != null && !grps.contains(grpName))
                     continue;
 
-                GridCacheContext<?, ?> cctx = F.first(gctx.caches());
-
-                if (cctx == null)
-                    continue;
-
                 if (arg instanceof WalEnableCommandArg)
-                    ignite.cluster().enableWal(cctx.name());
+                    ignite.cluster().enableWal(grpName);
                 else
-                    ignite.cluster().disableWal(cctx.name());
+                    ignite.cluster().disableWal(grpName);
             }
 
             return null;

modules/core/src/test/java/org/apache/ignite/internal/processors/cache/WalModeChangeAdvancedSelfTest.java

@@ -19,9 +19,7 @@
 
 import java.io.File;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -569,7 +567,8 @@ public void testCacheDestroy() throws Exception {
                     String msg = e.getMessage();
 
                     assert msg.startsWith("Cache doesn't exist") ||
-                        msg.startsWith("Failed to change WAL mode because some caches no longer exist") :
+                        msg.startsWith("Failed to change WAL mode because some caches no longer exist") ||
+                        msg.startsWith("Cache names cannot be empty.") :
                         e.getMessage();
                 }
                 finally {
@@ -737,7 +736,7 @@ public void testWalModeChangeRequiresAllGroupCaches() throws Exception {
 
         assertThrows(
             () -> {
-                srv.cluster().disableWal(Collections.singleton(CACHE_NAME_2));
+                srv.cluster().disableWal(CACHE_NAME_2);
                 return null;
             },
             IgniteException.class,
@@ -749,14 +748,14 @@ public void testWalModeChangeRequiresAllGroupCaches() throws Exception {
 
         assertThrows(
             () -> {
-                srv.cluster().enableWal(Collections.singleton(CACHE_NAME));
+                srv.cluster().enableWal(CACHE_NAME);
                 return null;
             },
             IgniteException.class,
             "Cannot change WAL mode because not all cache names belonging to the group are provided"
         );
 
-        srv.cluster().disableWal(Arrays.asList(CACHE_NAME, CACHE_NAME_2));
+        srv.cluster().disableWal("testGroup");
 
         assertForAllNodes(CACHE_NAME, false);
         assertForAllNodes(CACHE_NAME_2, false);
@@ -770,7 +769,7 @@ public void testWalModeChangeRequiresAllGroupCaches() throws Exception {
             "Cannot change WAL mode because not all cache names belonging to the group are provided"
         );
 
-        srv.cluster().enableWal(Arrays.asList(CACHE_NAME, CACHE_NAME_2));
+        srv.cluster().enableWal("testGroup");
 
         assertForAllNodes(CACHE_NAME, true);
         assertForAllNodes(CACHE_NAME_2, true);

modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteClusterProcessProxy.java

@@ -168,22 +168,12 @@ public IgniteClusterProcessProxy(IgniteProcessProxy proxy) {
     }
 
     /** {@inheritDoc} */
-    @Override public boolean enableWal(String cacheName) throws IgniteException {
+    @Override public boolean enableWal(String cacheOrGrpName) throws IgniteException {
         throw new UnsupportedOperationException("Operation is not supported yet.");
     }
 
     /** {@inheritDoc} */
-    @Override public boolean enableWal(Collection<String> cacheNames) throws IgniteException {
-        throw new UnsupportedOperationException("Operation is not supported yet.");
-    }
-
-    /** {@inheritDoc} */
-    @Override public boolean disableWal(String cacheName) throws IgniteException {
-        throw new UnsupportedOperationException("Operation is not supported yet.");
-    }
-
-    /** {@inheritDoc} */
-    @Override public boolean disableWal(Collection<String> cacheNames) throws IgniteException {
+    @Override public boolean disableWal(String cacheOrGrpName) throws IgniteException {
         throw new UnsupportedOperationException("Operation is not supported yet.");
     }