def sync_volume_backup_extra_details(self,
volume_backup_id,
after_update=False):
del self # unused
os_api = OSAdminApi()
volume_backup = VolumeBackup.objects.filter(id=volume_backup_id).first()
if volume_backup:
os_volume_backup_details = os_api.volume_backups.get(
volume_backup).get_details_from_os()
if os_volume_backup_details:
volume_backup.is_incremental = os_volume_backup_details.is_incremental
volume_backup.name = os_volume_backup_details.name
volume_backup.object_count = os_volume_backup_details.object_count
volume_backup.description = os_volume_backup_details.description
volume_backup.save()
if volume_backup.is_incremental is True and after_update is False:
related_full_backup = VolumeBackup.objects.filter(
volume=volume_backup.volume, is_incremental=False).first()
if related_full_backup:
os_related_full_backup_details = os_api.volume_backups.get(
related_full_backup).get_details_from_os()
if os_related_full_backup_details:
related_full_backup.has_dependent_backups = os_related_full_backup_details.has_dependent_backups
related_full_backup.object_count = os_related_full_backup_details.object_count
related_full_backup.save()
else:
related_full_backup.delete()
else:
volume_backup.delete()
def sync_volume_extra_details(self, volume_id, region_name):
del self # unused
os_api = OSAdminApi()
cc = cinder_client(api_session=os_api.get_session(),
region_name=region_name)
try:
volume_from_os = cc.volumes.get(volume_id)
except cinder_exceptions.NotFound:
pass
else:
db_volume = Volume.objects.filter(id=volume_id).first()
if db_volume and volume_from_os:
if volume_from_os.bootable == 'true':
db_volume.bootable = True
if volume_from_os.bootable == 'false':
db_volume.bootable = False
db_volume.save()
def perform_create(self, serializer: StaffVolumeBackupCreateSerializer):
if not validate_cloud_objects_limit():
raise APIBadRequest(
_('Licence cloud objects limit reached. Please check your license.'
))
volume_id = serializer.validated_data.get('volume_id')
volume = Volume.objects.filter(id=volume_id).first()
if volume:
if serializer.validated_data.pop('for_client'):
try:
volume_related_project = volume.project
except Project.DoesNotExist:
raise APIBadRequest(
_('Cannot create volume backup for client because related volume has not '
'client project associated'))
else:
project_id_used = volume_related_project.project_id
os_api = OSApi.from_project_id(
project_id=volume_related_project.project_id)
else:
project_id_used = plugin_settings.USER_PROJECT_ID
os_api = OSAdminApi()
if serializer.validated_data.get('incremental') is True:
if not has_full_backup_for_incremental_backup(
project_id=project_id_used, related_volume=volume):
# for incremental backups check if a full backup related to the volume exists in the same project
# - openstack doesn't validate this at specific project level
raise APIBadRequest(detail=_(
'Cannot create incremental backup without having a full backup first '
'in your os project'))
try:
volume_backup = os_api.volume_backups.create(
region_id=volume.region,
**serializer.validated_data,
)
activity_helper.add_current_activity_params(
object_id=volume_backup.id)
except Exception as e:
LOG.error(e)
handle(self.request,
message=_('Unable to create volume backup'))
return Response(
{'detail': _('Volume backup creation in progress')})
else:
raise APIBadRequest(
_('Cannot create volume backup as related volume does not exist'
))
def perform_create(self, serializer: StaffVolumeSnapshotCreateSerializer):
if not validate_cloud_objects_limit():
raise APIBadRequest(
_('Licence cloud objects limit reached. Please check your license.'
))
volume_id = serializer.validated_data.get('volume_id')
for_client = serializer.validated_data.pop('for_client', False)
volume = Volume.objects.filter(id=volume_id).first()
if volume:
try:
if for_client:
if not volume.project:
raise APIBadRequest(
_('Cannot create snapshot for client as volume does not have a related '
'project in the database.'))
if volume.project.project_id == plugin_settings.user_project_id:
raise APIBadRequest(
_('The volume is in the admin project. No client found.'
))
os_api = OSApi.from_project_id(
project_id=volume.project.project_id)
else:
os_api = OSAdminApi()
volume_snapshot = os_api.volume_snapshots.create(
region_name=volume.region,
**serializer.validated_data,
)
activity_helper.add_current_activity_params(
object_id=volume_snapshot.id)
except Exception as e:
handle(self.request, message=str(e))
return Response(
{'detail': _('Volume snapshot creation in progress')})
else:
raise APIBadRequest(
_('Cannot create volume snapshot as related volume does not exist'
))
def run(self, *args, **kwargs):
backup_id = kwargs.get('backup_id')
volume_id = kwargs.get('volume_id')
if not backup_id or not volume_id:
return self.abort_operation()
os_api = OSAdminApi()
if not kwargs.get('volume_was_synced', False):
# sync the volume when ready
db_volume = Volume.objects.filter(id=volume_id).first()
if db_volume:
os_volume = os_api.volumes.get(volume=db_volume)
os_volume_details = os_volume.get_os_details()
if not os_volume_details:
return self.abort_operation()
db_volume.status = os_volume_details.status
db_volume.save() # ensure it is up to date
if (os_volume_details.status != VolumeStatus.CREATING
and os_volume_details.status !=
VolumeStatus.RESTORING_BACKUP):
# volume is not creating anymore, we can sync it
timestamp = utcnow().isoformat()
vh = VolumeSyncHandler()
vh.create_or_update(volume=os_volume_details,
region=db_volume.region,
timestamp=timestamp)
operation_params = {
'backup_id':
backup_id,
'volume_id':
volume_id,
'volume_was_synced':
True,
'volume_backup_was_synced':
kwargs.get('volume_backup_was_synced', False),
}
self.db_operation.params = json.dumps(operation_params)
self.db_operation.save()
if not kwargs.get('volume_backup_was_synced', False):
# sync the volume backup when ready
db_volume_backup = VolumeBackup.objects.filter(
id=backup_id).first()
if not db_volume_backup:
return self.abort_operation()
os_volume_backup = os_api.volume_backups.get(
volume_backup=db_volume_backup)
os_volume_backup_details = os_volume_backup.get_details_from_os()
if not os_volume_backup_details:
return self.abort_operation()
db_volume_backup.status = os_volume_backup_details.status
db_volume_backup.save() # ensure it is up to date
if os_volume_backup_details.status != VolumeBackupStatus.RESTORING:
# volume backup is not restoring anymore, we can sync it
timestamp = utcnow().isoformat()
vbh = VolumeBackupSyncHandler()
vbh.create_or_update(data=os_volume_backup_details,
region=db_volume_backup.region,
timestamp=timestamp)
operation_params = {
'backup_id': backup_id,
'volume_id': volume_id,
'volume_backup_was_synced': True,
'volume_was_synced': kwargs.get('volume_was_synced',
False),
}
self.db_operation.params = json.dumps(operation_params)
self.db_operation.save()
if kwargs.get('volume_backup_was_synced', False) and kwargs.get(
'volume_was_synced', False):
return self.abort_operation()
def get_os_api(self, request):
del request # unused
return OSAdminApi()
def get_openstack_volume_snapshot(self, volume_snapshot=None):
volume_snapshot = volume_snapshot or self.get_object()
os_api = OSAdminApi()
return os_api.volume_snapshots.get(volume_snapshot=volume_snapshot)
def get_volume(self, volume=None):
volume = volume or self.get_object()
os_api = OSAdminApi()
return os_api.volumes.get(volume)
def get_openstack_volume_backup(self, volume_backup=None):
volume_backup = volume_backup or self.get_object()
os_api = OSAdminApi()
return os_api.volume_backups.get(volume_backup=volume_backup)