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)