[Mold] Incremental backup 지원

api/src/main/java/org/apache/cloudstack/api/command/admin/backup/ListBackupProvidersCmd.java

@@ -30,6 +30,7 @@
 import org.apache.cloudstack.api.response.ListResponse;
 import org.apache.cloudstack.backup.BackupManager;
 import org.apache.cloudstack.backup.BackupProvider;
+import org.apache.cloudstack.backup.BackupProviderNameUtils;
 
 import com.cloud.user.Account;
 
@@ -70,11 +71,12 @@ private void setupResponse(final List<BackupProvider> providers) {
         final ListResponse<BackupProviderResponse> response = new ListResponse<>();
         final List<BackupProviderResponse> responses = new ArrayList<>();
         for (final BackupProvider provider : providers) {
-            if (provider == null || (getName() != null && !provider.getName().equals(getName()))) {
+            final String displayName = provider == null ? null : BackupProviderNameUtils.toDisplayName(provider.getName());
+            if (provider == null || (getName() != null && !displayName.equalsIgnoreCase(getName()))) {
                 continue;
             }
             final BackupProviderResponse backupProviderResponse = new BackupProviderResponse();
-            backupProviderResponse.setName(provider.getName());
+            backupProviderResponse.setName(displayName);
             backupProviderResponse.setDescription(provider.getDescription());
             backupProviderResponse.setObjectName("providers");
             responses.add(backupProviderResponse);

api/src/main/java/org/apache/cloudstack/api/command/admin/backup/ListBackupProvidersForZoneCmd.java

@@ -31,6 +31,7 @@
 import org.apache.cloudstack.api.response.ZoneResponse;
 import org.apache.cloudstack.backup.BackupManager;
 import org.apache.cloudstack.backup.BackupProvider;
+import org.apache.cloudstack.backup.BackupProviderNameUtils;
 
 import com.cloud.user.Account;
 
@@ -75,7 +76,7 @@ private void setupResponse(final List<BackupProvider> providers) {
                 continue;
             }
             final BackupProviderResponse backupProviderResponse = new BackupProviderResponse();
-            backupProviderResponse.setName(provider.getName());
+            backupProviderResponse.setName(BackupProviderNameUtils.toDisplayName(provider.getName()));
             backupProviderResponse.setDescription(provider.getDescription());
             backupProviderResponse.setObjectName("providers");
             responses.add(backupProviderResponse);

api/src/main/java/org/apache/cloudstack/backup/AblestackBackupFrameworkUtils.java

@@ -0,0 +1,131 @@
+// 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.cloudstack.backup;
+
+import com.cloud.vm.VirtualMachine;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public final class AblestackBackupFrameworkUtils {
+
+    private AblestackBackupFrameworkUtils() {
+    }
+
+    public static int getEffectiveIncrementalLimit(final int defaultLimit, final List<Integer> scheduleMaxBackups) {
+        int effectiveLimit = defaultLimit;
+        if (scheduleMaxBackups == null) {
+            return effectiveLimit;
+        }
+        for (Integer maxBackups : scheduleMaxBackups) {
+            if (maxBackups != null && maxBackups > 0) {
+                effectiveLimit = Math.min(effectiveLimit, maxBackups);
+            }
+        }
+        return effectiveLimit;
+    }
+
+    public static <T extends Backup> int getBackupChainSize(final T latestBackup, final Map<String, ? extends T> backupsByUuid,
+            final Function<T, String> parentBackupUuidResolver) {
+        if (latestBackup == null) {
+            return 0;
+        }
+        int chainSize = 1;
+        T current = latestBackup;
+        while (current != null) {
+            final String parentBackupUuid = parentBackupUuidResolver.apply(current);
+            if (parentBackupUuid == null) {
+                break;
+            }
+            current = backupsByUuid.get(parentBackupUuid);
+            if (current != null) {
+                chainSize++;
+            }
+        }
+        return chainSize;
+    }
+
+    public static boolean requiresRunningVmAttach(final VirtualMachine.State vmState) {
+        return VirtualMachine.State.Running.equals(vmState);
+    }
+
+    public static boolean shouldExecuteRestoreOnSourceHost(final VirtualMachine.State vmState) {
+        return !requiresRunningVmAttach(vmState);
+    }
+
+    public static BackupRestorePlan createRestorePlan(final boolean attachRequired, final boolean cleanupRequired) {
+        final List<BackupRestoreStage> stages = new ArrayList<>();
+        stages.add(BackupRestoreStage.PREPARE_SOURCE);
+        stages.add(BackupRestoreStage.VALIDATE_CHAIN);
+        stages.add(BackupRestoreStage.RESTORE_DATA);
+        if (attachRequired) {
+            stages.add(BackupRestoreStage.ATTACH_VOLUME);
+        }
+        if (cleanupRequired) {
+            stages.add(BackupRestoreStage.CLEANUP_SOURCE);
+        }
+        return new BackupRestorePlan(stages);
+    }
+
+    public static boolean hasRestoreStage(final BackupRestorePlan restorePlan, final BackupRestoreStage stage) {
+        return restorePlan == null || restorePlan.hasStage(stage);
+    }
+
+    public static List<String> sanitizeChainFiles(final List<String> chainFiles) {
+        final LinkedHashSet<String> sanitized = new LinkedHashSet<>();
+        if (chainFiles == null) {
+            return new ArrayList<>();
+        }
+        for (final String chainFile : chainFiles) {
+            if (StringUtils.isNotBlank(chainFile)) {
+                sanitized.add(chainFile.trim());
+            }
+        }
+        return new ArrayList<>(sanitized);
+    }
+
+    public static void validateVolumeChainStates(final List<BackupVolumeChainState> volumeChainStates) {
+        if (volumeChainStates == null || volumeChainStates.isEmpty()) {
+            throw new IllegalArgumentException("Backup volume chain states cannot be empty");
+        }
+        for (final BackupVolumeChainState volumeChainState : volumeChainStates) {
+            if (volumeChainState == null) {
+                throw new IllegalArgumentException("Backup volume chain state cannot be null");
+            }
+            if (StringUtils.isBlank(volumeChainState.getVolumeUuid())) {
+                throw new IllegalArgumentException("Backup volume chain state must include a volume UUID");
+            }
+            if (sanitizeChainFiles(volumeChainState.getChainFiles()).isEmpty()) {
+                throw new IllegalArgumentException(String.format("Backup volume chain state for volume [%s] must include at least one chain file",
+                        volumeChainState.getVolumeUuid()));
+            }
+        }
+    }
+
+    public static boolean hasUsableVolumeChainStates(final List<BackupVolumeChainState> volumeChainStates) {
+        try {
+            validateVolumeChainStates(volumeChainStates);
+            return true;
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+}

api/src/main/java/org/apache/cloudstack/backup/BackupManager.java

@@ -32,7 +32,6 @@
 import org.apache.cloudstack.api.command.user.backup.ListBackupsCmd;
 import org.apache.cloudstack.api.response.BackupResponse;
 import org.apache.cloudstack.framework.config.ConfigKey;
-import org.apache.cloudstack.framework.config.ValidatedConfigKey;
 import org.apache.cloudstack.framework.config.Configurable;
 
 import com.cloud.exception.ResourceUnavailableException;
@@ -54,11 +53,10 @@ public interface BackupManager extends BackupService, Configurable, PluggableSer
             "false",
             "Is backup and recovery framework enabled.", false, ConfigKey.Scope.Zone);
 
-    ConfigKey<String> BackupProviderPlugin = new ValidatedConfigKey<>("Advanced", String.class,
+    ConfigKey<String> BackupProviderPlugin = new ConfigKey<>("Advanced", String.class,
             "backup.framework.provider.plugin",
             "dummy",
-            "The backup and recovery provider plugin. Valid plugin values: dummy, veeam, networker, bx and nas",
-            true, ConfigKey.Scope.Zone, BackupFrameworkEnabled.key(), value -> validateBackupProviderConfig((String)value));
+            "The backup and recovery provider plugin.", true, ConfigKey.Scope.Zone, BackupFrameworkEnabled.key());
 
     ConfigKey<Long> BackupSyncPollingInterval = new ConfigKey<>("Advanced", Long.class,
             "backup.framework.sync.interval",
@@ -70,6 +68,23 @@ public interface BackupManager extends BackupService, Configurable, PluggableSer
             "false",
             "Enable volume attach/detach operations for VMs that are assigned to Backup Offerings.", true);
 
+    ConfigKey<Boolean> KvmIncrementalBackup = new ConfigKey<>("Advanced", Boolean.class,
+            "kvm.incremental.backup",
+            "false",
+            "Enable KVM incremental backups for supported backup providers.",
+            false,
+            ConfigKey.Scope.Cluster,
+            null);
+
+    ConfigKey<Integer> BackupChainSize = new ConfigKey<>(Integer.class,
+            "backup.chain.size",
+            "Advanced",
+            "10",
+            "Max incremental backup chain size before switching back to a full backup for KVM backup providers.",
+            true,
+            ConfigKey.Scope.Global,
+            null);
+
     ConfigKey<Long> DefaultMaxAccountBackups = new ConfigKey<Long>("Account Defaults", Long.class,
             "max.account.backups",
             "20",
@@ -253,13 +268,4 @@ public interface BackupManager extends BackupService, Configurable, PluggableSer
 
     void checkAndRemoveBackupOfferingBeforeExpunge(VirtualMachine vm);
 
-    static void validateBackupProviderConfig(String value) {
-        if (value != null && (value.contains(",") || value.trim().contains(" "))) {
-            throw new IllegalArgumentException("Multiple backup provider plugins are not supported. Please provide a single plugin value.");
-        }
-        List<String> validPlugins = List.of("dummy", "veeam", "networker", "nas", "bx");
-        if (value != null && !validPlugins.contains(value)) {
-            throw new IllegalArgumentException("Invalid backup provider plugin: " + value + ". Valid plugin values are: " + String.join(", ", validPlugins));
-        }
-    }
 }

api/src/main/java/org/apache/cloudstack/backup/BackupProvider.java

@@ -79,6 +79,10 @@ public interface BackupProvider {
      */
     Pair<Boolean, Backup> takeBackup(VirtualMachine vm, Boolean quiesceVM);
 
+    default Pair<Boolean, Backup> takeBackup(VirtualMachine vm, Boolean quiesceVM, Long backupScheduleId) {
+        return takeBackup(vm, quiesceVM);
+    }
+
     /**
      * Delete an existing backup
      * @param backup The backup to exclude
@@ -170,4 +174,50 @@ default boolean supportsMemoryVmSnapshot() {
      * update commvault backup plan
      */
     boolean updateBackupPlan(Long zoneId, String retentionPeriod, String externalId);
+
+    default boolean supportsBackgroundSync() {
+        return true;
+    }
+
+    default boolean supportsBackupMetricsSync() {
+        return true;
+    }
+
+    default boolean supportsOutOfBandBackupSync() {
+        return true;
+    }
+
+    default boolean supportsProviderManagedBackupAgents() {
+        return false;
+    }
+
+    default boolean supportsRetentionPlanUpdate() {
+        return false;
+    }
+
+    default boolean supportsVolumeLevelChainState() {
+        return false;
+    }
+
+    default boolean supportsRestorePlan() {
+        return false;
+    }
+
+    default boolean supportsRestoreChainValidation() {
+        return false;
+    }
+
+    default boolean supportsPostRestoreMaintenance() {
+        return false;
+    }
+
+    default void runPostRestoreMaintenance(VirtualMachine vm, Backup backup, boolean volumeOnly) {
+    }
+
+    default boolean supportsBackgroundChainValidation() {
+        return false;
+    }
+
+    default void validateChains(Long zoneId) {
+    }
 }

api/src/main/java/org/apache/cloudstack/backup/BackupProviderNameUtils.java

@@ -0,0 +1,63 @@
+// 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.cloudstack.backup;
+
+import org.apache.commons.lang3.StringUtils;
+
+public final class BackupProviderNameUtils {
+    public static final String NAS = "nas";
+    public static final String COMMVAULT = "commvault";
+    public static final String ABLESTACK_NAS = "ablestack-nas";
+    public static final String ABLESTACK_COMMVAULT = "ablestack-commvault";
+
+    private BackupProviderNameUtils() {
+    }
+
+    public static String canonicalize(final String providerName) {
+        if (StringUtils.isBlank(providerName)) {
+            return providerName;
+        }
+        if (NAS.equalsIgnoreCase(providerName) || ABLESTACK_NAS.equalsIgnoreCase(providerName)) {
+            return ABLESTACK_NAS;
+        }
+        if (COMMVAULT.equalsIgnoreCase(providerName) || ABLESTACK_COMMVAULT.equalsIgnoreCase(providerName)) {
+            return ABLESTACK_COMMVAULT;
+        }
+        return providerName;
+    }
+
+    public static String toDisplayName(final String providerName) {
+        if (StringUtils.isBlank(providerName)) {
+            return providerName;
+        }
+        if (ABLESTACK_NAS.equalsIgnoreCase(providerName) || NAS.equalsIgnoreCase(providerName)) {
+            return NAS;
+        }
+        if (ABLESTACK_COMMVAULT.equalsIgnoreCase(providerName) || COMMVAULT.equalsIgnoreCase(providerName)) {
+            return COMMVAULT;
+        }
+        return providerName;
+    }
+
+    public static boolean isNasFamily(final String providerName) {
+        return ABLESTACK_NAS.equalsIgnoreCase(canonicalize(providerName));
+    }
+
+    public static boolean isCommvaultFamily(final String providerName) {
+        return ABLESTACK_COMMVAULT.equalsIgnoreCase(canonicalize(providerName));
+    }
+}