Keep maxbackups as null for Veeam where retention is enforced by Veeam.

Author: abh1sar

api/src/main/java/org/apache/cloudstack/api/command/user/backup/CreateBackupScheduleCmd.java

@@ -36,8 +36,6 @@
 import com.cloud.utils.DateUtil;
 import com.cloud.utils.exception.CloudRuntimeException;
 
-import java.util.Objects;
-
 @APICommand(name = "createBackupSchedule",
         description = "Creates a user-defined VM backup schedule",
         responseObject = BackupResponse.class, since = "4.14.0",
@@ -79,7 +77,6 @@ public class CreateBackupScheduleCmd extends BaseCmd {
 
     @Parameter(name = ApiConstants.MAX_BACKUPS,
             type = CommandType.INTEGER,
-            required = true,
             description = "maximum number of backups to retain",
             since = "4.21.0")
     private Integer maxBackups;
@@ -104,7 +101,9 @@ public String getTimezone() {
         return timezone;
     }
 
-    public Integer getMaxBackups() { return Objects.nonNull(maxBackups) ? maxBackups : 0; }
+    public Integer getMaxBackups() {
+        return maxBackups;
+    }
 
     /////////////////////////////////////////////////////
     /////////////// API Implementation///////////////////

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

@@ -30,5 +30,5 @@ public interface BackupSchedule extends InternalIdentity {
     String getTimezone();
     Date getScheduledTimestamp();
     Long getAsyncJobId();
-    int getMaxBackups();
+    Integer getMaxBackups();
 }

engine/schema/src/main/java/org/apache/cloudstack/backup/BackupScheduleVO.java

@@ -58,7 +58,7 @@ public class BackupScheduleVO implements BackupSchedule {
     Long asyncJobId;
 
     @Column(name = "max_backups")
-    int maxBackups = 0;
+    Integer maxBackups = 0;
 
     public BackupScheduleVO() {
     }
@@ -125,11 +125,11 @@ public void setAsyncJobId(Long asyncJobId) {
         this.asyncJobId = asyncJobId;
     }
 
-    public int getMaxBackups() {
+    public Integer getMaxBackups() {
         return maxBackups;
     }
 
-    public void setMaxBackups(int maxBackups) {
+    public void setMaxBackups(Integer maxBackups) {
         this.maxBackups = maxBackups;
     }
 }

engine/schema/src/main/resources/META-INF/db/schema-41910to42000.sql

@@ -412,7 +412,7 @@ CREATE TABLE `cloud`.`backup_repository` (
 ALTER TABLE `cloud`.`backup_schedule` DROP FOREIGN KEY fk_backup_schedule__vm_id;
 ALTER TABLE `cloud`.`backup_schedule` DROP INDEX vm_id;
 ALTER TABLE `cloud`.`backup_schedule` ADD CONSTRAINT fk_backup_schedule__vm_id FOREIGN KEY (vm_id) REFERENCES vm_instance(id) ON DELETE CASCADE;
-ALTER TABLE `cloud`.`backup_schedule` ADD COLUMN `max_backups` int(8) NOT NULL default 0 COMMENT 'maximum number of backups to maintain';
+ALTER TABLE `cloud`.`backup_schedule` ADD COLUMN `max_backups` int(8) default NULL COMMENT 'maximum number of backups to maintain';
 ALTER TABLE `cloud`.`backups` ADD COLUMN `backup_interval_type` int(5) COMMENT 'type of backup, e.g. manual, recurring - hourly, daily, weekly or monthly';
 
 -- Add volume details to the backups table to keep track of the volumes being backed up

server/src/main/java/org/apache/cloudstack/backup/BackupManagerImpl.java

@@ -443,13 +443,13 @@ public BackupSchedule configureBackupSchedule(CreateBackupScheduleCmd cmd) {
         if (vm.getBackupOfferingId() == null) {
             throw new CloudRuntimeException("Cannot configure backup schedule for the VM without having any backup offering");
         }
-        if (maxBackups <= 0) {
+        if (maxBackups != null && maxBackups <= 0) {
             throw new InvalidParameterValueException(String.format("maxBackups [%s] for instance %s should be greater than 0.", maxBackups, vm.getName()));
         }
 
         Backup.Type backupType = Backup.Type.valueOf(intervalType.name());
         int intervalMaxBackups = backupType.getMax();
-        if (maxBackups > intervalMaxBackups) {
+        if (maxBackups != null && maxBackups > intervalMaxBackups) {
             throw new InvalidParameterValueException(String.format("maxBackups [%s] for instance %s exceeds limit [%s] for interval type [%s].", maxBackups, vm.getName(),
                     intervalMaxBackups, intervalType));
         }
@@ -458,7 +458,7 @@ public BackupSchedule configureBackupSchedule(CreateBackupScheduleCmd cmd) {
 
         long accountLimit = resourceLimitMgr.findCorrectResourceLimitForAccount(owner, Resource.ResourceType.backup, null);
         long domainLimit = resourceLimitMgr.findCorrectResourceLimitForDomain(domainManager.getDomain(owner.getDomainId()), Resource.ResourceType.backup, null);
-        if (!accountManager.isRootAdmin(owner.getId()) && ((accountLimit != -1 && maxBackups > accountLimit) || (domainLimit != -1 && maxBackups > domainLimit))) {
+        if (maxBackups != null && !accountManager.isRootAdmin(owner.getId()) && ((accountLimit != -1 && maxBackups > accountLimit) || (domainLimit != -1 && maxBackups > domainLimit))) {
             String message = "domain/account";
             if (owner.getType() == Account.Type.PROJECT) {
                 message = "domain/project";
@@ -471,6 +471,13 @@ public BackupSchedule configureBackupSchedule(CreateBackupScheduleCmd cmd) {
             throw new CloudRuntimeException("The selected backup offering does not allow user-defined backup schedule");
         }
 
+        if (maxBackups == null && !"veeam".equals(offering.getProvider())) {
+            throw new CloudRuntimeException("Please specify the maximum number of buckets to retain.");
+        }
+        if (maxBackups != null && "veeam".equals(offering.getProvider())) {
+            throw new CloudRuntimeException("The maximum backups to retain cannot be configured through CloudStack for Veeam. Retention is managed directly in Veeam based on the settings specified when creating the backup job.");
+        }
+
         final String timezoneId = timeZone.getID();
         if (!timezoneId.equals(cmd.getTimezone())) {
             logger.warn("Using timezone: " + timezoneId + " for running this snapshot policy as an equivalent of " + cmd.getTimezone());
@@ -535,7 +542,10 @@ private void postCreateScheduledBackup(Backup.Type backupType, Long vmId) {
         if (schedule == null) {
             return;
         }
-        int maxBackups = schedule.getMaxBackups();
+        Integer maxBackups = schedule.getMaxBackups();
+        if (maxBackups == null) {
+            return;
+        }
         List<BackupVO> backups = backupDao.listBackupsByVMandIntervalType(vmId, backupType);
         while (backups.size() > maxBackups) {
             BackupVO oldestBackup = backups.get(0);

server/src/test/java/org/apache/cloudstack/backup/BackupManagerTest.java

@@ -418,8 +418,8 @@ public void testCreateScheduledBackup() throws ResourceAllocationException {
         Long accountId = 5L;
         Long backupId = 6L;
         Long oldestBackupId = 7L;
-        Long newBackupSize = 1000000L;
-        Long oldBackupSize = 9999999L;
+        Long newBackupSize = 1000000000L;
+        Long oldBackupSize = 400000000L;
 
         VMInstanceVO vm = Mockito.mock(VMInstanceVO.class);
         when(vmInstanceDao.findById(vmId)).thenReturn(vm);
@@ -448,6 +448,7 @@ public void testCreateScheduledBackup() throws ResourceAllocationException {
         BackupProvider backupProvider = mock(BackupProvider.class);
         Backup backup = mock(Backup.class);
         when(backup.getId()).thenReturn(backupId);
+        when(backup.getProtectedSize()).thenReturn(newBackupSize);
         when(backupProvider.getName()).thenReturn("test");
         when(backupProvider.takeBackup(vm)).thenReturn(new Pair<>(true, backup));
         Map<String, BackupProvider> backupProvidersMap = new HashMap<>();
@@ -456,7 +457,6 @@ public void testCreateScheduledBackup() throws ResourceAllocationException {
 
         BackupVO backupVO = mock(BackupVO.class);
         when(backupVO.getId()).thenReturn(backupId);
-        when(backupVO.getProtectedSize()).thenReturn(newBackupSize);
         BackupVO oldestBackupVO = mock(BackupVO.class);
         when(oldestBackupVO.getProtectedSize()).thenReturn(oldBackupSize);
         when(oldestBackupVO.getId()).thenReturn(oldestBackupId);

ui/src/views/compute/backup/FormSchedule.vue

@@ -205,7 +205,6 @@ export default {
         timeSelect: [{ type: 'object', required: true, message: this.$t('message.error.time') }],
         'day-of-week': [{ type: 'number', required: true, message: `${this.$t('message.error.select')}` }],
         'day-of-month': [{ required: true, message: `${this.$t('message.error.select')}` }],
-        maxbackups: [{ required: true, message: this.$t('message.error.required.input') }],
         timezone: [{ required: true, message: `${this.$t('message.error.select')}` }]
       })
     },