content: // 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 java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Date;
  import java.util.List;
  import java.util.Map;
  import java.util.UUID;
  
  import javax.inject.Inject;
  
  import com.cloud.offering.DiskOffering;
  import com.cloud.storage.StoragePoolHostVO;
  import com.cloud.storage.Volume;
  import com.cloud.storage.VolumeVO;
  import com.cloud.storage.dao.DiskOfferingDao;
  import com.cloud.storage.dao.StoragePoolHostDao;
  import com.cloud.storage.dao.VolumeDao;
  
  import org.apache.cloudstack.backup.dao.BackupDao;
  
  import com.cloud.utils.Pair;
  import com.cloud.utils.component.AdapterBase;
  import com.cloud.utils.exception.CloudRuntimeException;
  import com.cloud.vm.VMInstanceVO;
  import com.cloud.vm.VirtualMachine;
  
  public class DummyBackupProvider extends AdapterBase implements BackupProvider {
      @Inject
      private BackupDao backupDao;
      @Inject
      private VolumeDao volumeDao;
      @Inject
      private BackupManager backupManager;
      @Inject
      private StoragePoolHostDao storagePoolHostDao;
      @Inject
      private DiskOfferingDao diskOfferingDao;
  
      @Override
      public Boolean crossZoneInstanceCreationEnabled(BackupOffering backupOffering) {
          return true;
      }
  
      @Override
      public String getName() {
          return "dummy";
      }
  
      @Override
      public String getDescription() {
          return "Dummy Backup Plugin";
      }
  
      @Override
      public List<BackupOffering> listBackupOfferings(Long zoneId) {
          logger.debug("Listing backup policies on Dummy B&R Plugin");
          BackupOffering policy1 = new BackupOfferingVO(1, "gold-policy", "dummy", "Golden Policy", "Gold description", true);
          BackupOffering policy2 = new BackupOfferingVO(1, "silver-policy", "dummy", "Silver Policy", "Silver description", true);
          return Arrays.asList(policy1, policy2);
      }
  
      @Override
      public boolean isValidProviderOffering(Long zoneId, String uuid) {
          logger.debug("Checking if backup offering exists on the Dummy Backup Provider");
          return true;
      }
  
      @Override
      public boolean assignVMToBackupOffering(VirtualMachine vm, BackupOffering backupOffering) {
          logger.debug("Creating VM backup for VM {} from backup offering {}", vm, backupOffering);
          ((VMInstanceVO) vm).setBackupExternalId("dummy-external-backup-id");
          return true;
      }
  
      @Override
      public boolean restoreVMFromBackup(VirtualMachine vm, Backup backup) {
          logger.debug("Restoring vm {} from backup {} on the Dummy Backup Provider", vm, backup);
          return true;
      }
  
      @Override
      public Pair<Boolean, String> restoreBackedUpVolume(Backup backup, Backup.VolumeInfo backupVolumeInfo, String hostIp, String dataStoreUuid, Pair<String, VirtualMachine.State> vmNameAndState) {
          final VolumeVO volume = volumeDao.findByUuid(backupVolumeInfo.getUuid());
          final StoragePoolHostVO dataStore = storagePoolHostDao.findByUuid(dataStoreUuid);
          final DiskOffering diskOffering = diskOfferingDao.findByUuid(backupVolumeInfo.getDiskOfferingId());
  
          logger.debug("Restoring volume {} from backup {} on the Dummy Backup Provider", backupVolumeInfo, backup);
  
          VolumeVO restoredVolume = new VolumeVO(Volume.Type.DATADISK, null, backup.getZoneId(),
                  backup.getDomainId(), backup.getAccountId(), 0, null,
                  backup.getSize(), null, null, null);
          String volumeUUID = UUID.randomUUID().toString();
          String volumeName = volume != null ? volume.getName() : backupVolumeInfo.getUuid();
          restoredVolume.setName("RestoredVol-" + volumeName);
          restoredVolume.setProvisioningType(diskOffering.getProvisioningType());
          restoredVolume.setUpdated(new Date());
          restoredVolume.setUuid(volumeUUID);
          restoredVolume.setRemoved(null);
          restoredVolume.setDisplayVolume(true);
          restoredVolume.setPoolId(dataStore.getPoolId());
          restoredVolume.setPath(restoredVolume.getUuid());
          restoredVolume.setState(Volume.State.Copying);
          restoredVolume.setSize(backupVolumeInfo.getSize());
          restoredVolume.setDiskOfferingId(diskOffering.getId());
  
          try {
              volumeDao.persist(restoredVolume);
          } catch (Exception e) {
              throw new CloudRuntimeException("Unable to create restored volume due to: " + e);
          }
          return new Pair<>(true, volumeUUID);
      }
  
      public void syncBackupMetrics(Long zoneId) {
      }
  
      @Override
      public List<Backup.RestorePoint> listRestorePoints(VirtualMachine vm) {
          return null;
      }
  
      @Override
      public Backup createNewBackupEntryForRestorePoint(Backup.RestorePoint restorePoint, VirtualMachine vm) {
          return null;
      }
  
      @Override
      public boolean removeVMFromBackupOffering(VirtualMachine vm) {
          logger.debug("Removing VM {} from backup offering by the Dummy Backup Provider", vm);
          return true;
      }
  
      @Override
      public boolean willDeleteBackupsOnOfferingRemoval() {
          return false;
      }
  
      @Override
      public Pair<Boolean, Backup> takeBackup(VirtualMachine vm, Boolean quiesceVM) {
          logger.debug("Starting backup for VM {} on Dummy provider", vm);
  
          BackupVO backup = new BackupVO();
          backup.setVmId(vm.getId());
          backup.setExternalId("dummy-external-id");
          backup.setType("FULL");
          backup.setDate(new Date());
          long virtualSize = 0L;
          for (final Volume volume: volumeDao.findByInstance(vm.getId())) {
              if (Volume.State.Ready.equals(volume.getState())) {
                  virtualSize += volume.getSize();
              }
          }
          backup.setSize(virtualSize);
          backup.setProtectedSize(virtualSize);
          backup.setStatus(Backup.Status.BackedUp);
          backup.setBackupOfferingId(vm.getBackupOfferingId());
          backup.setAccountId(vm.getAccountId());
          backup.setDomainId(vm.getDomainId());
          backup.setZoneId(vm.getDataCenterId());
          backup.setName(backupManager.getBackupNameFromVM(vm));
          List<Volume> volumes = new ArrayList<>(volumeDao.findByInstance(vm.getId()));
          backup.setBackedUpVolumes(backupManager.createVolumeInfoFromVolumes(volumes));
          Map<String, String> details = backupManager.getBackupDetailsFromVM(vm);
          backup.setDetails(details);
  
          backup = backupDao.persist(backup);
          return new Pair<>(true, backup);
      }
  
      @Override
      public boolean deleteBackup(Backup backup, boolean forced) {
          return backupDao.remove(backup.getId());
      }
  
      @Override
      public boolean supportsInstanceFromBackup() {
          return true;
      }
  
      @Override
      public Pair<Long, Long> getBackupStorageStats(Long zoneId) {
          return new Pair<>(0L, 0L);
      }
  
      @Override
      public void syncBackupStorageStats(Long zoneId) {
      }
  
      @Override
      public Pair<Boolean, String> restoreBackupToVM(VirtualMachine vm, Backup backup, String hostIp, String dataStoreUuid) {
          return new Pair<>(true, null);
      }
  }
  