IGNITE-27033: Сheckpoint command added

modules/control-utility/src/test/java/org/apache/ignite/testsuites/IgniteControlUtilityTestSuite.java

@@ -24,6 +24,7 @@
 import org.apache.ignite.util.GridCommandHandlerBrokenIndexTest;
 import org.apache.ignite.util.GridCommandHandlerCheckIncrementalSnapshotTest;
 import org.apache.ignite.util.GridCommandHandlerCheckIndexesInlineSizeTest;
+import org.apache.ignite.util.GridCommandHandlerCheckpointTest;
 import org.apache.ignite.util.GridCommandHandlerClusterByClassTest;
 import org.apache.ignite.util.GridCommandHandlerClusterByClassWithSSLTest;
 import org.apache.ignite.util.GridCommandHandlerConsistencyRepairCorrectnessTransactionalTest;
@@ -80,7 +81,8 @@
     BaselineEventsRemoteTest.class,
 
     GridCommandHandlerConsistencyRepairCorrectnessTransactionalTest.class,
-    GridCommandHandlerWalTest.class
+    GridCommandHandlerWalTest.class,
+    GridCommandHandlerCheckpointTest.class
 })
 public class IgniteControlUtilityTestSuite {
 }

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

@@ -0,0 +1,155 @@
+/*
+ * 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.util;
+
+import java.util.Objects;
+import java.util.regex.Pattern;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.cluster.ClusterState;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.testframework.GridTestUtils;
+import org.apache.ignite.testframework.ListeningTestLogger;
+import org.apache.ignite.testframework.LogListener;
+import org.junit.Test;
+
+import static org.apache.ignite.internal.commandline.CommandHandler.EXIT_CODE_OK;
+import static org.apache.ignite.internal.commandline.CommandHandler.EXIT_CODE_UNEXPECTED_ERROR;
+
+/** Test for checkpoint in control.sh command. */
+public class GridCommandHandlerCheckpointTest extends GridCommandHandlerAbstractTest {
+    /** */
+    private final ListeningTestLogger listeningLog = new ListeningTestLogger(log);
+
+    /** */
+    private final LogListener checkpointFinishedLsnr = LogListener.matches("Checkpoint finished").build();
+
+    /** */
+    @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception {
+        IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName);
+
+        if (!persistenceEnable())
+            cfg.setDataStorageConfiguration(null);
+
+        listeningLog.registerListener(checkpointFinishedLsnr);
+
+        cfg.setGridLogger(listeningLog);
+
+        return cfg;
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTest() throws Exception {
+        super.beforeTest();
+        stopAllGrids();
+        cleanPersistenceDir();
+        injectTestSystemOut();
+    }
+
+    /** Test checkpoint command with persistence enabled. */
+    @Test
+    public void testCheckpointPersistenceCluster() throws Exception {
+        persistenceEnable(true);
+
+        IgniteEx srv = startGrids(2);
+        IgniteEx cli = startClientGrid("client");
+        srv.cluster().state(ClusterState.ACTIVE);
+
+        IgniteCache<Integer, Integer> cacheSrv = srv.getOrCreateCache(DEFAULT_CACHE_NAME);
+        IgniteCache<Integer, Integer> cacheCli = cli.getOrCreateCache(DEFAULT_CACHE_NAME);
+
+        cacheSrv.put(1, 1);
+        cacheCli.put(1, 1);
+
+        assertEquals(EXIT_CODE_OK, execute("--checkpoint"));
+
+        outputContains("Checkpoint triggered on all nodes");
+        assertTrue(GridTestUtils.waitForCondition(checkpointFinishedLsnr::check, 10_000));
+
+        String out = testOut.toString();
+        assertFalse(out.contains(cli.localNode().id().toString()));
+        assertFalse(out.contains(Objects.toString(cli.localNode().consistentId())));
+
+        testOut.reset();
+        checkpointFinishedLsnr.reset();
+
+        cacheSrv.put(2, 2);
+        cacheCli.put(2, 2);
+
+        assertEquals(EXIT_CODE_OK, execute("--checkpoint", "--reason", "test_reason"));
+
+        outputContains("Checkpoint triggered on all nodes");
+        assertTrue(GridTestUtils.waitForCondition(checkpointFinishedLsnr::check, 10_000));
+
+        testOut.reset();
+        checkpointFinishedLsnr.reset();
+
+        cacheSrv.put(3, 3);
+        cacheCli.put(3, 3);
+
+        assertEquals(EXIT_CODE_OK, execute("--checkpoint", "--wait-for-finish"));
+
+        outputContains("Checkpoint triggered on all nodes");
+        assertTrue(GridTestUtils.waitForCondition(checkpointFinishedLsnr::check, 10_000));
+
+        checkpointFinishedLsnr.reset();
+    }
+
+    /** Test checkpoint command with in-memory cluster. */
+    @Test
+    public void testCheckpointInMemoryCluster() throws Exception {
+        persistenceEnable(false);
+
+        IgniteEx srv = startGrids(2);
+        IgniteEx cli = startClientGrid("client");
+        srv.cluster().state(ClusterState.ACTIVE);
+
+        srv.createCache("testCache");
+        assertEquals(EXIT_CODE_UNEXPECTED_ERROR, execute("--checkpoint"));
+
+        outputContains("Can't checkpoint on in-memory node");
+        assertFalse(checkpointFinishedLsnr.check());
+
+        String out = testOut.toString();
+        assertFalse(out.contains(cli.localNode().id().toString()));
+        assertFalse(out.contains(Objects.toString(cli.localNode().consistentId())));
+
+        checkpointFinishedLsnr.reset();
+    }
+
+    /** Test checkpoint with timeout. */
+    @Test
+    public void testCheckpointTimeout() throws Exception {
+        persistenceEnable(true);
+
+        IgniteEx srv = startGrids(1);
+        srv.cluster().state(ClusterState.ACTIVE);
+
+        assertEquals(EXIT_CODE_OK, execute("--checkpoint", "--wait-for-finish", "--timeout", "1000"));
+
+        outputContains("Checkpoint triggered on all nodes");
+        assertTrue(checkpointFinishedLsnr.check());
+
+        checkpointFinishedLsnr.reset();
+    }
+
+    /** */
+    private void outputContains(String regexp) {
+        assertTrue(Pattern.compile(regexp).matcher(testOut.toString()).find());
+    }
+}

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

@@ -24,6 +24,7 @@
 import org.apache.ignite.internal.management.baseline.BaselineCommand;
 import org.apache.ignite.internal.management.cache.CacheCommand;
 import org.apache.ignite.internal.management.cdc.CdcCommand;
+import org.apache.ignite.internal.management.checkpoint.CheckpointCommand;
 import org.apache.ignite.internal.management.consistency.ConsistencyCommand;
 import org.apache.ignite.internal.management.defragmentation.DefragmentationCommand;
 import org.apache.ignite.internal.management.diagnostic.DiagnosticCommand;
@@ -58,6 +59,7 @@ public IgniteCommandRegistry() {
             new TxCommand(),
             new CacheCommand(),
             new WalCommand(),
+            new CheckpointCommand(),
             new DiagnosticCommand(),
             new EncryptionCommand(),
             new KillCommand(),

modules/core/src/main/java/org/apache/ignite/internal/management/checkpoint/CheckpointCommand.java

@@ -0,0 +1,53 @@
+/*
+ * 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.management.checkpoint;
+
+import java.util.Collection;
+import java.util.function.Consumer;
+import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.internal.management.api.CommandUtils;
+import org.apache.ignite.internal.management.api.ComputeCommand;
+import org.jetbrains.annotations.Nullable;
+
+/** Checkpoint command. */
+public class CheckpointCommand implements ComputeCommand<CheckpointCommandArg, String> {
+    /** {@inheritDoc} */
+    @Override public Class<CheckpointTask> taskClass() {
+        return CheckpointTask.class;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String description() {
+        return "Trigger checkpoint with optional parameters";
+    }
+
+    /** {@inheritDoc} */
+    @Override public Class<CheckpointCommandArg> argClass() {
+        return CheckpointCommandArg.class;
+    }
+
+    /** {@inheritDoc} */
+    @Override public @Nullable Collection<ClusterNode> nodes(Collection<ClusterNode> nodes, CheckpointCommandArg arg) {
+        return CommandUtils.servers(nodes);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void printResult(CheckpointCommandArg arg, String res, Consumer<String> printer) {
+        printer.accept(res);
+    }
+}

modules/core/src/main/java/org/apache/ignite/internal/management/checkpoint/CheckpointCommandArg.java

@@ -0,0 +1,87 @@
+/*
+ * 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.management.checkpoint;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.internal.dto.IgniteDataTransferObject;
+import org.apache.ignite.internal.management.api.Argument;
+import org.apache.ignite.internal.util.typedef.internal.U;
+
+/** Checkpoint command arguments. */
+public class CheckpointCommandArg extends IgniteDataTransferObject {
+    /** */
+    private static final long serialVersionUID = 0;
+
+    /** */
+    @Argument(description = "Reason for checkpoint", optional = true)
+    private String reason;
+
+    /** */
+    @Argument(description = "Wait for checkpoint to finish", optional = true)
+    private boolean waitForFinish;
+
+    /** */
+    @Argument(description = "Timeout in milliseconds", optional = true)
+    private long timeout = -1;
+
+    /** {@inheritDoc} */
+    @Override protected void writeExternalData(ObjectOutput out) throws IOException {
+        U.writeString(out, reason);
+        out.writeBoolean(waitForFinish);
+        out.writeObject(timeout);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException {
+        reason = U.readString(in);
+        waitForFinish = in.readBoolean();
+        timeout = (long)in.readObject();
+    }
+
+    /** */
+    public String reason() {
+        return reason;
+    }
+
+    /** */
+    public void reason(String reason) {
+        this.reason = reason;
+    }
+
+    /** */
+    public boolean waitForFinish() {
+        return waitForFinish;
+    }
+
+    /** */
+    public void waitForFinish(boolean waitForFinish) {
+        this.waitForFinish = waitForFinish;
+    }
+
+    /** */
+    public long timeout() {
+        return timeout;
+    }
+
+    /** */
+    public void timeout(long timeout) {
+        this.timeout = timeout;
+    }
+}