def _vm_create_cb_failed(result, task_id, vm, inform_user=True):
"""
Callback helper for failed task - revert status and inform user.
"""
# revert status
if result['meta']['apiview']['recreate']:
if result['message'].find('Successfully deleted') == 0:
Snapshot.objects.filter(vm=vm).delete()
SnapshotDefine.objects.filter(vm=vm).delete()
BackupDefine.objects.filter(vm=vm).delete()
vm.save_metadata('installed',
False,
save=True,
update_fields=('enc_json', 'changed'))
revert_state = Vm.NOTCREATED
else:
revert_state = Vm.STOPPED
else:
revert_state = Vm.NOTCREATED
# save reverted status and inform user
if inform_user:
if vm.status != revert_state:
vm_status_changed(task_id, vm, revert_state, save_state=True)
else:
vm.status = revert_state
vm.save_status()
def put(self): # noqa: R701
request, vm, action = self.request, self.vm, self.action
# Cannot change status unless the VM is created on node
if vm.status not in self.statuses and action != 'current':
raise VmIsNotOperational
if action not in self.actions:
raise ExpectationFailed('Bad action')
apiview = self.apiview
f_ser = VmStatusFreezeSerializer(data=self.data)
if f_ser.is_valid():
freeze = apiview['freeze'] = f_ser.data['freeze']
unfreeze = apiview['unfreeze'] = f_ser.data['unfreeze']
else:
return FailureTaskResponse(request, f_ser.errors, vm=vm)
if ((action == 'start' and vm.status == Vm.STOPPED and not freeze) or
(action == 'reboot' and vm.status == Vm.RUNNING and not freeze) or
(action == 'stop' and vm.status in (Vm.STOPPING, Vm.RUNNING))):
pass
elif action == 'stop' and vm.status == Vm.STOPPED and freeze:
if not request.user.is_admin(request):
raise PermissionDenied
tid = task_id_from_request(request,
owner_id=vm.owner.id,
dummy=True)
vm_status_changed(tid, vm, vm.FROZEN, save_state=True)
res = {
'message':
'VM %s is already stopped. Changing status to frozen.' %
vm.hostname
}
return SuccessTaskResponse(request, res, task_id=tid, vm=vm)
elif action == 'stop' and vm.status == Vm.FROZEN and unfreeze:
if not request.user.is_admin(request):
raise PermissionDenied
tid = task_id_from_request(request,
owner_id=vm.owner.id,
dummy=True)
vm_status_changed(tid, vm, vm.STOPPED, save_state=True)
res = {
'message': 'Removing frozen status for VM %s.' % vm.hostname
}
return SuccessTaskResponse(request, res, task_id=tid, vm=vm)
elif action == 'current':
# Limit PUT /current/ action to be Admins and SuperAdmins
if not request.user.is_admin(request):
raise PermissionDenied
if vm.status in self.statuses_force_change_allowed:
return self.get_current_status(force_change=True)
elif vm.status in self.stuck_statuses_force_change_allowed:
if vm.tasks:
raise VmHasPendingTasks
else:
return self.get_current_status(force_change=True)
else:
raise VmIsNotOperational
else:
raise ExpectationFailed('Bad action')
dc_settings = request.dc.settings
if action in ('stop',
'reboot') and vm.uuid in dc_settings.VMS_NO_SHUTDOWN:
raise PreconditionRequired('Internal VM can\'t be stopped')
lock = 'vm_status vm:%s' % vm.uuid
stdin = None
apiview['update'] = False
transition_to_stopping = False
# The update parameter is used by all actions (start, stop, reboot)
ser_update = VmStatusUpdateJSONSerializer(data=self.data,
default=(action
in ('start',
'reboot')))
if not ser_update.is_valid():
return FailureTaskResponse(request, ser_update.errors, vm=vm)
if vm.json_changed():
apiview['update'] = ser_update.data['update']
logger.info('VM %s json != json_active', vm)
if not apiview['update']:
logger.info('VM %s json_active update disabled', vm)
if action == 'start':
ser = VmStatusActionIsoSerializer(request, vm, data=self.data)
if not ser.is_valid():
return FailureTaskResponse(request, ser.errors, vm=vm)
if ser.data and ser.iso:
if not request.user.is_admin(request) and vm.is_installed() and \
(ser.iso.name != dc_settings.VMS_ISO_RESCUECD):
raise PreconditionRequired('VM is not installed')
msg = LOG_START_ISO
iso = ser.iso
cmd = self._start_cmd(iso=iso,
iso2=ser.iso2,
once=ser.data['cdimage_once'])
else:
msg = LOG_START
iso = None
cmd = self._start_cmd()
if apiview['update']:
if vm.tasks:
raise VmHasPendingTasks
cmd, stdin = self._add_update_cmd(cmd, os_cmd_allowed=False)
if iso:
msg = LOG_START_UPDATE_ISO
else:
msg = LOG_START_UPDATE
else:
ser_stop_reboot = VmStatusStopSerializer(request,
vm,
data=self.data)
if not ser_stop_reboot.is_valid():
return FailureTaskResponse(request,
ser_stop_reboot.errors,
vm=vm)
update = apiview.get('update',
False) # VmStatusUpdateJSONSerializer
force = apiview['force'] = ser_stop_reboot.data.get('force', False)
timeout = ser_stop_reboot.data.get('timeout', None)
if not force and timeout:
apiview['timeout'] = timeout
if update:
if vm.tasks:
raise VmHasPendingTasks
# This will always perform a vmadm stop command, followed by a vmadm update command and optionally
# followed by a vmadm start command (reboot)
pre_cmd = self._action_cmd('stop',
force=force,
timeout=timeout)
if action == 'reboot':
if force:
msg = LOG_REBOOT_FORCE_UPDATE
else:
msg = LOG_REBOOT_UPDATE
post_cmd = self._action_cmd('start')
else:
if force:
msg = LOG_STOP_FORCE_UPDATE
else:
msg = LOG_STOP_UPDATE
post_cmd = ''
cmd, stdin = self._add_update_cmd(post_cmd,
os_cmd_allowed=True,
pre_cmd=pre_cmd)
else:
cmd = self._action_cmd(action, force=force, timeout=timeout)
if force:
if action == 'reboot':
msg = LOG_REBOOT_FORCE
else:
lock += ' force'
msg = LOG_STOP_FORCE
else:
if action == 'reboot':
msg = LOG_REBOOT
else:
msg = LOG_STOP
if vm.status == Vm.STOPPING:
if update:
raise PreconditionRequired(
'Cannot perform update while VM is stopping')
if not force:
raise VmIsNotOperational(
'VM is already stopping; try to use force')
else:
transition_to_stopping = True
meta = {
'output': {
'returncode': 'returncode',
'stderr': 'message',
'stdout': 'json'
},
'replace_stderr': ((vm.uuid, vm.hostname), ),
'detail': self.detail,
'msg': msg,
'vm_uuid': vm.uuid,
'apiview': apiview,
'last_status': vm.status,
}
callback = ('api.vm.status.tasks.vm_status_cb', {'vm_uuid': vm.uuid})
tid, err = execute(request,
vm.owner.id,
cmd,
stdin=stdin,
meta=meta,
lock=lock,
callback=callback,
queue=vm.node.fast_queue)
if err:
return FailureTaskResponse(request, err, vm=vm)
else:
if transition_to_stopping:
vm.save_status(Vm.STOPPING)
return TaskResponse(request,
tid,
msg=msg,
vm=vm,
api_view=apiview,
detail=self.detail,
data=self.data,
api_data={
'status': vm.status,
'status_display': vm.status_display()
})
def post(self):
request, vm = self.request, self.vm
ser = VmCreateSerializer(data=self.data)
if not ser.is_valid():
return FailureTaskResponse(request, ser.errors, vm=vm)
if not vm.is_kvm():
if not (vm.dc.settings.VMS_VM_SSH_KEYS_DEFAULT or vm.owner.usersshkey_set.exists()):
raise PreconditionRequired('VM owner has no SSH keys available')
apiview = self.apiview
# noinspection PyTypeChecker
cmd = 'vmadm create >&2; e=$? %s; vmadm get %s 2>/dev/null; vmadm start %s >&2; exit $e' % (
self.fix_create(vm), vm.uuid, vm.uuid)
recreate = apiview['recreate'] = ser.data['recreate']
# noinspection PyAugmentAssignment
if recreate:
# recreate should be available to every vm owner
if not (request.user and request.user.is_authenticated()):
raise PermissionDenied
if vm.locked:
raise VmIsLocked
if vm.status != vm.STOPPED:
raise VmIsNotOperational('VM is not stopped')
if not ser.data['force']:
raise ExpectationFailed('Are you sure?')
msg = LOG_VM_RECREATE
# noinspection PyAugmentAssignment
cmd = 'vmadm delete ' + vm.uuid + ' >&2 && sleep 1; ' + cmd
elif vm.status == vm.NOTCREATED:
# only admin
if not (request.user and request.user.is_admin(request)):
raise PermissionDenied
if not vm.node: # we need to find a node for this vm now
logger.debug('VM %s has no compute node defined. Choosing node automatically', vm)
VmDefineView(request).choose_node(vm)
logger.info('New compute node %s for VM %s was chosen automatically.', vm.node, vm)
msg = LOG_VM_CREATE
else:
raise VmIsNotOperational('VM is already created')
# Check boot flag (KVM) or disk image (OS) (bug #chili-418)
if not vm.is_bootable():
raise PreconditionRequired('VM has no bootable disk')
if vm.tasks:
raise VmHasPendingTasks
old_status = vm.status
deploy = apiview['deploy'] = vm.is_deploy_needed()
resize = apiview['resize'] = vm.is_resize_needed()
if not vm.is_blank():
vm.set_root_pw()
# Set new status also for blank VM (where deployment is not needed)
# This status will be changed in vm_status_event_cb (if everything goes well).
vm.status = vm.CREATING
vm.save() # save status / node / vnc_port / root_pw
stdin = vm.fix_json(deploy=deploy, resize=resize, recreate=recreate).dump()
meta = {
'output': {'returncode': 'returncode', 'stderr': 'message', 'stdout': 'json'},
'replace_stderr': ((vm.uuid, vm.hostname),),
'msg': msg,
'vm_uuid': vm.uuid,
'apiview': apiview
}
callback = ('api.vm.base.tasks.vm_create_cb', {'vm_uuid': vm.uuid})
err = True
try:
# Possible node_image import task which will block this task on node worker
block_key = self.node_image_import(vm.node, vm.json_get_disks())
logger.debug('Creating new VM %s on node %s with json: """%s"""', vm, vm.node, stdin)
tid, err = execute(request, vm.owner.id, cmd, stdin=stdin, meta=meta, expires=VM_VM_EXPIRES, lock=self.lock,
callback=callback, queue=vm.node.slow_queue, block_key=block_key)
if err:
return FailureTaskResponse(request, err, vm=vm)
else:
# Inform user about creating
vm_status_changed(tid, vm, vm.CREATING, save_state=False)
return TaskResponse(request, tid, msg=msg, vm=vm, api_view=apiview, data=self.data)
finally:
if err: # Revert old status
vm.status = old_status
vm.save_status()
def put(self):
request, vm, action = self.request, self.vm, self.action
# Cannot change status unless the VM is created on node
if vm.status not in self.statuses:
raise VmIsNotOperational
if action not in self.actions:
raise ExpectationFailed('Bad action')
apiview = self.apiview
f_ser = VmStatusFreezeSerializer(data=self.data)
if f_ser.is_valid():
freeze = apiview['freeze'] = f_ser.data['freeze']
unfreeze = apiview['unfreeze'] = f_ser.data['unfreeze']
else:
return FailureTaskResponse(request, f_ser.errors, vm=vm)
if ((action == 'start' and vm.status == Vm.STOPPED and not freeze) or
(action == 'reboot' and vm.status == Vm.RUNNING and not freeze) or
(action == 'stop' and vm.status in (Vm.STOPPING, Vm.RUNNING))):
pass
elif action == 'stop' and vm.status == Vm.STOPPED and freeze:
if not request.user.is_admin(request):
raise PermissionDenied
tid = task_id_from_request(request,
owner_id=vm.owner.id,
dummy=True)
vm_status_changed(tid, vm, vm.FROZEN, save_state=True)
res = {
'message':
'VM %s is already stopped. Changing status to frozen.' %
vm.hostname
}
return SuccessTaskResponse(request, res, task_id=tid, vm=vm)
elif action == 'stop' and vm.status == Vm.FROZEN and unfreeze:
if not request.user.is_admin(request):
raise PermissionDenied
tid = task_id_from_request(request,
owner_id=vm.owner.id,
dummy=True)
vm_status_changed(tid, vm, vm.STOPPED, save_state=True)
res = {
'message': 'Removing frozen status for VM %s.' % vm.hostname
}
return SuccessTaskResponse(request, res, task_id=tid, vm=vm)
else:
raise ExpectationFailed('Bad action')
dc_settings = request.dc.settings
if action in ('stop',
'reboot') and vm.uuid in dc_settings.VMS_NO_SHUTDOWN:
raise PreconditionRequired('Internal VM can\'t be stopped')
lock = 'vm_status vm:%s' % vm.uuid
stdin = None
apiview['update'] = False
transition_to_stopping = False
if action == 'start':
msg = LOG_START
ser = VmStatusActionIsoSerializer(request, vm, data=self.data)
if not ser.is_valid():
return FailureTaskResponse(request, ser.errors, vm=vm)
if ser.data and ser.iso:
if not request.user.is_admin(request) and vm.is_installed() and \
(ser.iso.name != dc_settings.VMS_ISO_RESCUECD):
raise PreconditionRequired('VM is not installed')
msg = LOG_START_ISO
iso = ser.iso
cmd = self._start_cmd(iso=iso,
iso2=ser.iso2,
once=ser.data['cdimage_once'])
else:
iso = None
cmd = self._start_cmd()
ser_update = VmStatusUpdateJSONSerializer(data=self.data)
if ser_update.is_valid():
if vm.json_changed():
apiview['update'] = ser_update.data['update']
logger.info('VM %s json != json_active', vm)
if apiview['update']:
from api.vm.base.vm_manage import VmManage
stdin, os_cmd = VmManage.fix_update(vm.json_update())
stdin = stdin.dump()
if os_cmd: # Dangerous, explicit update needed
# TODO: fix in gui
raise PreconditionRequired(
'VM must be updated first')
if iso:
msg = LOG_START_UPDATE_ISO
else:
msg = LOG_START_UPDATE
cmd_update = 'vmadm update %s >&2; e=$?; vmadm get %s 2>/dev/null; ' % (
vm.uuid, vm.uuid)
cmd = cmd_update + cmd + '; exit $e'
# logger.info('VM %s json_active is going to be updated with json """%s"""', vm, stdin)
else:
logger.warning('VM %s json_active update disabled', vm)
else:
return FailureTaskResponse(request, ser_update.errors, vm=vm)
else:
force = ForceSerializer(data=self.data, default=False).is_true()
cmd = self._action_cmd(action, force=force)
if action == 'reboot':
msg = LOG_REBOOT
else:
msg = LOG_STOP
if force:
apiview['force'] = True
if action == 'reboot':
msg = LOG_REBOOT_FORCE
else:
lock += ' force'
msg = LOG_STOP_FORCE
elif vm.status == Vm.STOPPING:
raise VmIsNotOperational(
'VM is already stopping; try to use force')
else:
transition_to_stopping = True
meta = {
'output': {
'returncode': 'returncode',
'stderr': 'message',
'stdout': 'json'
},
'replace_stderr': ((vm.uuid, vm.hostname), ),
'detail': self.detail,
'msg': msg,
'vm_uuid': vm.uuid,
'apiview': apiview,
'last_status': vm.status,
}
callback = ('api.vm.status.tasks.vm_status_cb', {'vm_uuid': vm.uuid})
tid, err = execute(request,
vm.owner.id,
cmd,
stdin=stdin,
meta=meta,
lock=lock,
callback=callback,
queue=vm.node.fast_queue)
if err:
return FailureTaskResponse(request, err, vm=vm)
else:
if transition_to_stopping:
vm.save_status(Vm.STOPPING)
return TaskResponse(request,
tid,
msg=msg,
vm=vm,
api_view=apiview,
detail=self.detail,
data=self.data,
api_data={
'status': vm.status,
'status_display': vm.status_display()
})
