def get(self):
request, data, vm = self.request, self.data, self.vm
# Prepare filter dict
snap_filter = {'vm': vm}
filter_disk_id(vm, snap_filter, data)
filter_snap_type(snap_filter, data)
filter_snap_define(snap_filter, data)
# TODO: check indexes
snapqs = Snapshot.objects.select_related('vm', 'define').filter(**snap_filter).order_by(*self.order_by)
if self.full or self.extended:
if snapqs:
res = SnapshotSerializer(request, snapqs, many=True).data
else:
res = []
else:
res = list(snapqs.values_list('name', flat=True))
return SuccessTaskResponse(request, res, vm=vm)
def delete(self):
"""Delete multiple backups"""
# TODO: not documented :(
bkp_filter = filter_disk_id(None,
self.bkp_filter,
self.data,
default=1) # vm_disk_id instead of disk_id
bkps, __ = get_backups(self.request, bkp_filter,
self.data) # Parse data['bkpnames']
bkps_lost = bkps.filter(status=Backup.LOST)
bkp = bkps[0]
vm = bkp.vm
self.bkp = bkp
self.disk_id = bkp.array_disk_id
if vm:
self._check_vm(vm)
obj = vm
else:
obj = bkp.node
if bkps_lost:
self._check_bkp_node(bkp.node)
_result = {'message': 'Backups successfully deleted from DB'}
_detail = self._detail(bkpnames=[i.name for i in bkps_lost])
bkps_lost.delete()
res = SuccessTaskResponse(self.request,
_result,
msg=LOG_BKPS_DELETE,
obj=obj,
detail=_detail)
bkps = bkps.filter(
status=Backup.OK) # Work with OK backups from now on
if not bkps:
return res
bkpnames = [i.name for i in bkps]
self.bkps = bkps
self.bkpnames = bkpnames
self._check_bkp()
self._check_bkp_node(bkp.node)
self.msg = LOG_BKPS_DELETE
self.obj = obj
if self.execute(get_backup_cmd('delete', bkp, bkps=bkps),
lock=self.LOCK % (bkp.vm_uuid, bkp.disk_id)):
bkps.update(status=Backup.PENDING)
return self.task_response
return self.error_response
def vm_define_backup_list(request, hostname_or_uuid, data=None):
"""
List (:http:get:`GET </vm/(hostname_or_uuid)/define/backup>`) all VM backup definitions.
.. http:get:: /vm/(hostname_or_uuid)/define/backup
:DC-bound?:
* |dc-yes|
:Permissions:
* |VmOwner|
:Asynchronous?:
* |async-no|
:arg hostname_or_uuid: **required** - Server hostname or uuid
:type hostname_or_uuid: string
:arg data.full: Return list of objects with all backup definition details (default: false)
:type data.full: boolean
:arg data.disk_id: Filter by disk number/ID
:type data.disk_id: integer
:arg data.extended: Include total number of backups for each backup definition (default: false)
:type data.extended: boolean
:arg data.order_by: :ref:`Available fields for sorting <order_by>`: ``name``, ``disk_id``, ``created`` \
(default: ``-created``)
:type data.order_by: string
:status 200: SUCCESS
:status 403: Forbidden
:status 404: VM not found
:status 412: Invalid disk_id
"""
vm = get_vm(request,
hostname_or_uuid,
exists_ok=True,
noexists_fail=True,
sr=('node', 'owner'))
query_filter = {'vm': vm}
query_filter = filter_disk_id(vm, query_filter, data)
extra = output_extended_backup_count(request, data)
# TODO: check indexes
bkp_define = BackupDefine.objects.select_related('vm', 'vm__dc', 'node', 'zpool', 'periodic_task',
'periodic_task__crontab')\
.filter(**query_filter).order_by(*BackupDefineView.get_order_by(data))
if extra:
bkp_define = bkp_define.extra(extra)
return BackupDefineView(request, data=data).get(vm,
bkp_define,
many=True,
extended=bool(extra))
def __init__(self, request, hostname_or_uuid, bkpname, data):
super(VmBackup, self).__init__(request)
if request.method == 'POST': # Got bkpdef instead of bkpname
vm = get_vm(request, hostname_or_uuid, exists_ok=True, noexists_fail=True)
disk_id, real_disk_id, zfs_filesystem = get_disk_id(request, vm, data)
# TODO: check indexes
define = get_object(request, BackupDefine, {'name': bkpname, 'vm': vm, 'disk_id': real_disk_id},
exists_ok=True, noexists_fail=True, sr=('vm', 'node'))
bkpname = define.generate_backup_name()
bkp_get = {'name': bkpname, 'vm_hostname': vm.hostname, 'vm_disk_id': disk_id - 1, 'vm': vm}
else:
try:
if 'hostname' in data: # Force original hostname
raise ObjectNotFound
# Only target VM status and backup node status are important
vm = get_vm(request, hostname_or_uuid, exists_ok=True, noexists_fail=True, check_node_status=None)
except ObjectNotFound:
vm = None
bkp_get = {'name': bkpname, 'vm_hostname': hostname_or_uuid}
else:
bkp_get = {'vm': vm, 'name': bkpname}
define = None
real_disk_id = None
zfs_filesystem = None
bkp_get = filter_disk_id(None, bkp_get, data, default=1) # vm_disk_id instead of disk_id
bkp_get['dc'] = request.dc
# Backup instance
self.bkp = bkp = get_object(request, Backup, bkp_get, sr=('node', 'define', 'vm'))
self.disk_id = bkp.array_disk_id
self.hostname = bkp.vm_hostname_real
self.define = define
self.real_disk_id = real_disk_id
self.zfs_filesystem = zfs_filesystem
self.vm = vm
self.data = data
# Task type (a = automatic, e = manual)
if getattr(request, 'define_id', None):
self.tt = TT_AUTO
else:
self.tt = TT_EXEC
def get(self):
request, data = self.request, self.data
bkp_filter = filter_disk_id(None, self.bkp_filter,
data) # vm_disk_id instead of disk_id
bkp_filter = filter_backup_define(bkp_filter, data)
# TODO: check indexes
bkps = Backup.objects.select_related(
'node', 'define',
'vm').filter(**bkp_filter).order_by(*self.order_by)
if self.full or self.extended:
if bkps:
res = BackupSerializer(request,
bkps,
node_view=self.node,
many=True).data
else:
res = []
else:
res = list(bkps.values_list('name', flat=True))
return SuccessTaskResponse(request, res)
