add new check for full backup command regards to continuous backup flag

Author: vinayakphegde

hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/impl/BackupCommands.java

@@ -47,6 +47,7 @@
 import java.io.IOException;
 import java.net.URI;
 import java.util.List;
+import java.util.Set;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.conf.Configured;
@@ -353,6 +354,46 @@ public void execute() throws IOException {
         throw new IOException(INCORRECT_USAGE);
       }
 
+      /*
+       * The `continuousBackup` flag is specified only during the first full backup to initiate
+       * continuous WAL replication. After that, it is redundant because the tables are already set
+       * up for continuous backup. If the `continuousBackup` flag is not explicitly enabled, we need
+       * to determine the backup mode based on the current state of the specified tables: - If all
+       * the specified tables are already part of continuous backup, we treat the request as a
+       * continuous backup request and proceed accordingly (since these tables are already
+       * continuously backed up, no additional setup is needed). - If none of the specified tables
+       * are part of continuous backup, we treat the request as a normal full backup without
+       * continuous backup. - If the request includes a mix of tables—some with continuous backup
+       * enabled and others without—we cannot determine a clear backup strategy. In this case, we
+       * throw an error. If all tables are already in continuous backup mode, we explicitly set the
+       * `continuousBackup` flag to `true` so that the request is processed using the continuous
+       * backup approach rather than the normal full backup flow.
+       */
+      if (!continuousBackup && tableNameList != null && !tableNameList.isEmpty()) {
+        try (BackupSystemTable backupSystemTable = new BackupSystemTable(conn)) {
+          Set<TableName> continuousBackupTableSet =
+            backupSystemTable.getContinuousBackupTableSet().keySet();
+
+          boolean allTablesInContinuousBackup = continuousBackupTableSet.containsAll(tableNameList);
+          boolean noTablesInContinuousBackup =
+            tableNameList.stream().noneMatch(continuousBackupTableSet::contains);
+
+          // Ensure that all tables are either fully in continuous backup or not at all
+          if (!allTablesInContinuousBackup && !noTablesInContinuousBackup) {
+            System.err
+              .println("ERROR: Some tables are already in continuous backup, while others are not. "
+                + "Cannot mix both in a single request.");
+            printUsage();
+            throw new IOException(INCORRECT_USAGE);
+          }
+
+          // If all tables are already in continuous backup, enable the flag
+          if (allTablesInContinuousBackup) {
+            continuousBackup = true;
+          }
+        }
+      }
+
       try (BackupAdminImpl admin = new BackupAdminImpl(conn)) {
         BackupRequest.Builder builder = new BackupRequest.Builder();
         BackupRequest request = builder.withBackupType(backupType).withTableList(tableNameList)

hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestContinuousBackup.java

@@ -95,7 +95,7 @@ public void testContinuousBackupWithFullBackup() throws Exception {
       int before = table.getBackupHistory().size();
 
       // Run backup
-      String[] args = buildBackupArgs("full", new TableName[] { tableName });
+      String[] args = buildBackupArgs("full", new TableName[] { tableName }, true);
       int ret = ToolRunner.run(conf1, new BackupDriver(), args);
       assertEquals("Backup should succeed", 0, ret);
 
@@ -133,12 +133,12 @@ public void testContinuousBackupForMultipleTables() throws Exception {
       int before = table.getBackupHistory().size();
 
       // Create full backup for table1
-      String[] args = buildBackupArgs("full", new TableName[] { tableName1 });
+      String[] args = buildBackupArgs("full", new TableName[] { tableName1 }, true);
       int ret = ToolRunner.run(conf1, new BackupDriver(), args);
       assertEquals("Backup should succeed", 0, ret);
 
       // Create full backup for table2
-      args = buildBackupArgs("full", new TableName[] { tableName2 });
+      args = buildBackupArgs("full", new TableName[] { tableName2 }, true);
       ret = ToolRunner.run(conf1, new BackupDriver(), args);
       assertEquals("Backup should succeed", 0, ret);
 
@@ -165,6 +165,39 @@ public void testContinuousBackupForMultipleTables() throws Exception {
     verifyTableInBackupSystemTable(tableName2);
   }
 
+  @Test
+  public void testInvalidBackupScenarioWithContinuousEnabled() throws Exception {
+    LOG.info("Testing invalid backup scenario with continuous backup enabled");
+    String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
+    TableName tableName1 = TableName.valueOf("table_" + methodName);
+    TEST_UTIL.createTable(tableName1, "cf");
+    TableName tableName2 = TableName.valueOf("table_" + methodName + "2");
+    TEST_UTIL.createTable(tableName2, "cf");
+
+    try (BackupSystemTable table = new BackupSystemTable(TEST_UTIL.getConnection())) {
+      int before = table.getBackupHistory().size();
+
+      // Create full backup for table1 with continuous backup enabled
+      String[] args = buildBackupArgs("full", new TableName[] { tableName1 }, true);
+      int ret = ToolRunner.run(conf1, new BackupDriver(), args);
+      assertEquals("Backup should succeed", 0, ret);
+
+      // Create full backup for table2 without continuous backup enabled
+      args = buildBackupArgs("full", new TableName[] { tableName2 }, false);
+      ret = ToolRunner.run(conf1, new BackupDriver(), args);
+      assertEquals("Backup should succeed", 0, ret);
+
+      // Attempt full backup for both tables without continuous backup enabled (should fail)
+      args = buildBackupArgs("full", new TableName[] { tableName1, tableName2 }, false);
+      ret = ToolRunner.run(conf1, new BackupDriver(), args);
+      assertTrue("Backup should fail due to mismatch in continuous backup settings", ret != 0);
+
+      // Verify backup history size is unchanged after the failed backup
+      int after = table.getBackupHistory().size();
+      assertEquals("Backup history should remain unchanged on failure", before + 2, after);
+    }
+  }
+
   @Test
   public void testContinuousBackupWithWALDirNotSpecified() throws Exception {
     LOG.info("Testing that continuous backup fails when WAL directory is not specified");
@@ -179,7 +212,7 @@ public void testContinuousBackupWithWALDirNotSpecified() throws Exception {
       int before = table.getBackupHistory().size();
 
       // Run full backup without specifying WAL directory (invalid scenario)
-      String[] args = buildBackupArgs("full", new TableName[] { tableName });
+      String[] args = buildBackupArgs("full", new TableName[] { tableName }, true);
       int ret = ToolRunner.run(conf1, new BackupDriver(), args);
 
       assertTrue("Backup should fail when WAL directory is not specified", ret != 0);
@@ -204,7 +237,7 @@ public void testContinuousBackupWithIncrementalBackup() throws Exception {
       int before = table.getBackupHistory().size();
 
       // Run incremental backup with continuous backup flag (invalid scenario)
-      String[] args = buildBackupArgs("incremental", new TableName[] { tableName });
+      String[] args = buildBackupArgs("incremental", new TableName[] { tableName }, true);
       int ret = ToolRunner.run(conf1, new BackupDriver(), args);
 
       assertTrue("Backup should fail when using continuous backup with incremental mode", ret != 0);
@@ -226,12 +259,17 @@ private void verifyReplicationPeerSubscription(TableName table) throws IOExcepti
     }
   }
 
-  private String[] buildBackupArgs(String backupType, TableName[] tables) {
+  private String[] buildBackupArgs(String backupType, TableName[] tables,
+    boolean continuousEnabled) {
     String tableNames =
       Arrays.stream(tables).map(TableName::getNameAsString).collect(Collectors.joining(","));
 
-    return new String[] { "create", backupType, BACKUP_ROOT_DIR, "-t", tableNames,
-      "-" + OPTION_ENABLE_CONTINUOUS_BACKUP };
+    if (continuousEnabled) {
+      return new String[] { "create", backupType, BACKUP_ROOT_DIR, "-t", tableNames,
+        "-" + OPTION_ENABLE_CONTINUOUS_BACKUP };
+    } else {
+      return new String[] { "create", backupType, BACKUP_ROOT_DIR, "-t", tableNames };
+    }
   }
 
   private BackupManifest getLatestBackupManifest(List<BackupInfo> backups) throws IOException {