Skip to content

Commit 0a126f8

Browse files
timoninmaximzstan
timoninmaxim
authored and
zstan
committed
IGNITE-27457 Add output for enable/disable WAL commands (#12711)
(cherry picked from commit 38ab8cf)
1 parent fba9935 commit 0a126f8

5 files changed

Lines changed: 195 additions & 34 deletions

File tree

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

Lines changed: 68 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -184,22 +184,78 @@ public void testWalChangeForMultiCacheGroup() throws Exception {
184184
srv.cluster().state(ClusterState.ACTIVE);
185185

186186
srv.createCache(new CacheConfiguration<>("cache1")
187-
.setGroupName("testGroup"));
187+
.setGroupName("group1"));
188188
srv.createCache(new CacheConfiguration<>("cache2")
189-
.setGroupName("testGroup"));
189+
.setGroupName("group1"));
190+
srv.createCache(new CacheConfiguration<>("cache3")
191+
.setGroupName("group2"));
192+
srv.createCache("cache4");
193+
194+
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "group1,group2,cache4"));
195+
outputContains(".*group1.*true.*true.*true.*true.*false");
196+
outputContains(".*group2.*true.*true.*true.*true.*false");
197+
outputContains(".*cache4.*true.*true.*true.*true.*false");
198+
199+
assertEquals(EXIT_CODE_OK, execute("--wal", "disable", "--groups", "group1"));
200+
outputContains("Successfully disabled WAL for groups:");
201+
outputContains("group1");
202+
203+
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "group1"));
204+
outputContains(".*group1.*true.*false.*true.*true.*false");
205+
206+
assertEquals(EXIT_CODE_OK, execute("--wal", "disable", "--groups", "group1,group2"));
207+
outputContains("Successfully disabled WAL for groups:");
208+
outputContains("group1");
209+
outputContains("group2");
210+
211+
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "group1,group2"));
212+
outputContains(".*group1.*true.*false.*true.*true.*false");
213+
outputContains(".*group2.*true.*false.*true.*true.*false");
214+
215+
assertEquals(EXIT_CODE_OK, execute("--wal", "disable", "--groups", "cache4,nonExistentGroup"));
216+
outputContains("Successfully disabled WAL for groups:");
217+
outputContains("cache4");
218+
outputContains("Failed to disable WAL for groups:");
219+
outputContains("nonExistentGroup - Cache group not found");
220+
221+
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "cache4"));
222+
outputContains(".*cache4.*true.*false.*true.*true.*false");
223+
224+
// Error when using cache name instead of group name.
225+
assertEquals(EXIT_CODE_OK, execute("--wal", "enable", "--groups", "cache3"));
226+
outputContains("Failed to enable WAL for groups:");
227+
outputContains("cache3 - Cache group not found");
228+
229+
assertEquals(EXIT_CODE_OK, execute("--wal", "enable", "--groups", "group2,cache4"));
230+
outputContains("Successfully enabled WAL for groups:");
231+
outputContains("group2");
232+
outputContains("cache4");
233+
234+
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "group2,cache4"));
235+
outputContains(".*group2.*true.*true.*true.*true.*false");
236+
outputContains(".*cache4.*true.*true.*true.*true.*false");
237+
238+
assertEquals(EXIT_CODE_OK, execute("--wal", "disable"));
239+
outputContains("Successfully disabled WAL for groups:");
240+
outputContains("group1");
241+
outputContains("group2");
242+
outputContains("cache4");
190243

191-
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "testGroup"));
192-
outputContains(".*testGroup.*true.*true.*true.*true.*false");
193-
194-
assertEquals(EXIT_CODE_OK, execute("--wal", "disable", "--groups", "testGroup"));
195-
196-
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "testGroup"));
197-
outputContains(".*testGroup.*true.*false.*true.*true.*false");
244+
assertEquals(EXIT_CODE_OK, execute("--wal", "state"));
245+
outputContains(".*group1.*true.*false.*true.*true.*false");
246+
outputContains(".*group2.*true.*false.*true.*true.*false");
247+
outputContains(".*cache4.*true.*false.*true.*true.*false");
198248

199-
assertEquals(EXIT_CODE_OK, execute("--wal", "enable", "--groups", "testGroup"));
249+
assertEquals(EXIT_CODE_OK, execute("--wal", "enable"));
250+
outputContains("Successfully enabled WAL for groups:");
251+
outputContains("group1");
252+
outputContains("group2");
253+
outputContains("cache4");
200254

201-
assertEquals(EXIT_CODE_OK, execute("--wal", "state", "--groups", "testGroup"));
202-
outputContains(".*testGroup.*true.*true.*true.*true.*false");
255+
assertEquals(EXIT_CODE_OK, execute("--wal", "state"));
256+
outputContains(".*group1.*true.*true.*true.*true.*false");
257+
outputContains(".*group2.*true.*true.*true.*true.*false");
258+
outputContains(".*cache4.*true.*true.*true.*true.*false");
203259
}
204260

205261
/** */

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

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,10 +17,11 @@
1717

1818
package org.apache.ignite.internal.management.wal;
1919

20+
import java.util.function.Consumer;
2021
import org.apache.ignite.internal.management.api.ComputeCommand;
2122

2223
/** */
23-
public class WalDisableCommand implements ComputeCommand<WalDisableCommand.WalDisableCommandArg, Void> {
24+
public class WalDisableCommand implements ComputeCommand<WalDisableCommand.WalDisableCommandArg, WalSetStateTaskResult> {
2425
/** {@inheritDoc} */
2526
@Override public Class<WalSetStateTask> taskClass() {
2627
return WalSetStateTask.class;
@@ -41,6 +42,11 @@ public class WalDisableCommand implements ComputeCommand<WalDisableCommand.WalDi
4142
return "Are you sure? Any node failure without WAL can lead to the loss of all PDS data. CDC events will be lost without WAL.";
4243
}
4344

45+
/** {@inheritDoc} */
46+
@Override public void printResult(WalDisableCommandArg arg, WalSetStateTaskResult res, Consumer<String> printer) {
47+
res.print(false, printer);
48+
}
49+
4450
/** */
4551
public static class WalDisableCommandArg extends WalStateCommandArg {
4652
/** */

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

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,11 +17,12 @@
1717

1818
package org.apache.ignite.internal.management.wal;
1919

20+
import java.util.function.Consumer;
2021
import org.apache.ignite.internal.management.api.ComputeCommand;
2122
import org.apache.ignite.internal.management.wal.WalDisableCommand.WalDisableCommandArg;
2223

2324
/** */
24-
public class WalEnableCommand implements ComputeCommand<WalDisableCommandArg, Void> {
25+
public class WalEnableCommand implements ComputeCommand<WalDisableCommandArg, WalSetStateTaskResult> {
2526
/** {@inheritDoc} */
2627
@Override public Class<WalSetStateTask> taskClass() {
2728
return WalSetStateTask.class;
@@ -37,6 +38,11 @@ public class WalEnableCommand implements ComputeCommand<WalDisableCommandArg, Vo
3738
return WalEnableCommandArg.class;
3839
}
3940

41+
/** {@inheritDoc} */
42+
@Override public void printResult(WalDisableCommandArg arg, WalSetStateTaskResult res, Consumer<String> printer) {
43+
res.print(true, printer);
44+
}
45+
4046
/** */
4147
public static class WalEnableCommandArg extends WalDisableCommandArg {
4248
/** */

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

Lines changed: 32 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -17,37 +17,34 @@
1717

1818
package org.apache.ignite.internal.management.wal;
1919

20+
import java.util.ArrayList;
2021
import java.util.Arrays;
21-
import java.util.HashSet;
22+
import java.util.HashMap;
2223
import java.util.List;
24+
import java.util.Map;
2325
import java.util.Set;
26+
import java.util.stream.Collectors;
2427
import org.apache.ignite.IgniteException;
25-
import org.apache.ignite.compute.ComputeJobResult;
2628
import org.apache.ignite.internal.management.wal.WalDisableCommand.WalDisableCommandArg;
2729
import org.apache.ignite.internal.management.wal.WalEnableCommand.WalEnableCommandArg;
2830
import org.apache.ignite.internal.processors.cache.CacheGroupContext;
2931
import org.apache.ignite.internal.util.typedef.F;
3032
import org.apache.ignite.internal.visor.VisorJob;
31-
import org.apache.ignite.internal.visor.VisorMultiNodeTask;
33+
import org.apache.ignite.internal.visor.VisorOneNodeTask;
3234
import org.jetbrains.annotations.Nullable;
3335

3436
/** */
35-
public class WalSetStateTask extends VisorMultiNodeTask<WalDisableCommandArg, Void, Void> {
37+
public class WalSetStateTask extends VisorOneNodeTask<WalDisableCommandArg, WalSetStateTaskResult> {
3638
/** */
3739
private static final long serialVersionUID = 0;
3840

3941
/** {@inheritDoc} */
40-
@Override protected VisorJob<WalDisableCommandArg, Void> job(WalDisableCommandArg arg) {
41-
return new WalDisableJob(arg, false);
42-
}
43-
44-
/** {@inheritDoc} */
45-
@Override protected @Nullable Void reduce0(List<ComputeJobResult> res) throws IgniteException {
46-
return null;
42+
@Override protected VisorJob<WalDisableCommandArg, WalSetStateTaskResult> job(WalDisableCommandArg arg) {
43+
return new WalDisableJob(arg, debug);
4744
}
4845

4946
/** */
50-
private static class WalDisableJob extends VisorJob<WalDisableCommandArg, Void> {
47+
private static class WalDisableJob extends VisorJob<WalDisableCommandArg, WalSetStateTaskResult> {
5148
/** */
5249
private static final long serialVersionUID = 0;
5350

@@ -57,22 +54,37 @@ protected WalDisableJob(@Nullable WalDisableCommandArg arg, boolean debug) {
5754
}
5855

5956
/** {@inheritDoc} */
60-
@Override protected Void run(@Nullable WalDisableCommandArg arg) throws IgniteException {
61-
Set<String> grps = F.isEmpty(arg.groups()) ? null : new HashSet<>(Arrays.asList(arg.groups()));
57+
@Override protected WalSetStateTaskResult run(@Nullable WalDisableCommandArg arg) throws IgniteException {
58+
Set<String> grps = arg.groups == null ? null : Arrays.stream(arg.groups).collect(Collectors.toSet());
59+
60+
List<String> successGrps = new ArrayList<>();
61+
Map<String, String> failedGrps = new HashMap<>();
6262

6363
for (CacheGroupContext gctx : ignite.context().cache().cacheGroups()) {
6464
String grpName = gctx.cacheOrGroupName();
6565

66-
if (grps != null && !grps.contains(grpName))
66+
if (grps != null && !grps.remove(grpName))
6767
continue;
6868

69-
if (arg instanceof WalEnableCommandArg)
70-
ignite.cluster().enableWal(grpName);
71-
else
72-
ignite.cluster().disableWal(grpName);
69+
try {
70+
if (arg instanceof WalEnableCommandArg)
71+
ignite.cluster().enableWal(grpName);
72+
else
73+
ignite.cluster().disableWal(grpName);
74+
75+
successGrps.add(grpName);
76+
}
77+
catch (IgniteException e) {
78+
failedGrps.put(grpName, e.getMessage());
79+
}
80+
}
81+
82+
if (!F.isEmpty(grps)) {
83+
for (String grp: grps)
84+
failedGrps.put(grp, "Cache group not found");
7385
}
7486

75-
return null;
87+
return new WalSetStateTaskResult(successGrps, failedGrps);
7688
}
7789
}
7890
}

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

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
/*
2+
* Licensed to the Apache Software Foundation (ASF) under one or more
3+
* contributor license agreements. See the NOTICE file distributed with
4+
* this work for additional information regarding copyright ownership.
5+
* The ASF licenses this file to You under the Apache License, Version 2.0
6+
* (the "License"); you may not use this file except in compliance with
7+
* the License. You may obtain a copy of the License at
8+
*
9+
* http://www.apache.org/licenses/LICENSE-2.0
10+
*
11+
* Unless required by applicable law or agreed to in writing, software
12+
* distributed under the License is distributed on an "AS IS" BASIS,
13+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14+
* See the License for the specific language governing permissions and
15+
* limitations under the License.
16+
*/
17+
18+
package org.apache.ignite.internal.management.wal;
19+
20+
import java.util.List;
21+
import java.util.Map;
22+
import java.util.function.Consumer;
23+
import org.apache.ignite.internal.Order;
24+
import org.apache.ignite.internal.dto.IgniteDataTransferObject;
25+
import org.apache.ignite.internal.util.typedef.F;
26+
27+
/**
28+
* Result of WAL enable/disable operation.
29+
*/
30+
public class WalSetStateTaskResult extends IgniteDataTransferObject {
31+
/** */
32+
private static final long serialVersionUID = 0L;
33+
34+
/** Successfully processed groups. */
35+
@Order(0)
36+
List<String> successGrps;
37+
38+
/** Errors by group name. */
39+
@Order(1)
40+
Map<String, String> errorsByGrp;
41+
42+
/** Default constructor. */
43+
public WalSetStateTaskResult() {
44+
// No-op.
45+
}
46+
47+
/**
48+
* Constructor.
49+
*
50+
* @param successGrps Successfully processed groups.
51+
* @param errorsByGrp Error messages.
52+
*/
53+
public WalSetStateTaskResult(List<String> successGrps, Map<String, String> errorsByGrp) {
54+
this.successGrps = successGrps;
55+
this.errorsByGrp = errorsByGrp;
56+
}
57+
58+
/**
59+
* Print WAL disable/enable command result.
60+
*
61+
* @param enable If {@code true} then "enable" operation, otherwise "disable".
62+
* @param printer Output consumer.
63+
*/
64+
void print(boolean enable, Consumer<String> printer) {
65+
String op = enable ? "enable" : "disable";
66+
67+
if (!successGrps.isEmpty()) {
68+
printer.accept("Successfully " + op + "d WAL for groups:");
69+
70+
for (String grp : successGrps)
71+
printer.accept(" " + grp);
72+
}
73+
74+
if (!F.isEmpty(errorsByGrp)) {
75+
printer.accept("Failed to " + op + " WAL for groups:");
76+
77+
for (Map.Entry<String, String> entry : errorsByGrp.entrySet())
78+
printer.accept(" " + entry.getKey() + " - " + entry.getValue());
79+
}
80+
}
81+
}

0 commit comments

Comments
 (0)