def test_0001_list_task(self):
task_obj = Task(self.client)
status_list = [TaskStatus.ERROR.value]
records = task_obj.list_tasks(filter_status_list=status_list)
n = len(list(records))
self.logger.debug('found %s tasks' % n)
assert n > 0
def update_task(self,
status,
message=None,
error_message=None,
stack_trace=''):
if not self.tenant_client.is_sysadmin():
stack_trace = ''
if self.task is None:
self.task = Task(self.sys_admin_client)
if message is None:
message = OP_MESSAGE[self.op]
if self.task_resource is not None:
task_href = self.task_resource.get('href')
else:
task_href = None
self.task_resource = self.task.update(
status=status.value,
namespace='vcloud.cse',
operation=message,
operation_name=self.op,
details='',
progress=None,
owner_href=f"urn:cse:cluster:{self.cluster_id}",
owner_name=self.cluster_name,
owner_type='application/vcloud.cse.cluster+xml',
user_href=self.tenant_info['user_id'],
user_name=self.tenant_info['user_name'],
org_href=self.tenant_info['org_href'],
task_href=task_href,
error_message=error_message,
stack_trace=stack_trace)
def reload_templates(request_data, op_ctx):
"""."""
user_context = op_ctx.get_user_context(api_version=None)
user_client = user_context.client
if not user_client.is_sysadmin:
raise e.UnauthorizedRequestError(
error_message=
'Unauthorized to reload CSE native and TKG templates.' # noqa: E501
)
org = vcd_utils.get_org(user_client, user_context.org_name)
user_href = org.get_user(user_context.name).get('href')
task = Task(user_client)
task_resource = task.update(
status=TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation="Reloading native templates.",
operation_name='template operation',
details='',
progress=None,
owner_href=user_context.org_href,
owner_name=user_context.org_name,
owner_type='application/vnd.vmware.vcloud.org+xml',
user_href=user_href,
user_name=user_context.name,
org_href=user_context.org_href)
task_href = task_resource.get('href')
op_ctx.is_async = True
_reload_templates_async(op_ctx, task_href)
return {"task_href": task_href}
def remove_vdc_compute_policy_from_vdc(
self,
request_context: ctx.RequestContext, # noqa: E501
ovdc_id,
compute_policy_href,
remove_compute_policy_from_vms=False): # noqa: E501
"""Delete the compute policy from the specified vdc.
Note: The VDC compute policy need not be created by CSE.
:param request_context: request context of remove compute policy
request
:param str ovdc_id: id of the vdc to assign the policy
:param compute_policy_href: policy href to remove
:param bool remove_compute_policy_from_vms: If True, will set affected
VMs' compute policy to 'System Default'
:return: dictionary containing 'task_href'.
"""
# TODO find an efficient way without passing in request context
vdc = vcd_utils.get_vdc(self._sysadmin_client, vdc_id=ovdc_id)
org = vcd_utils.get_org(self._sysadmin_client)
org.reload()
user_name = self._session.get('user')
user_href = org.get_user(user_name).get('href')
task = Task(self._sysadmin_client)
task_resource = task.update(
status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=f"Removing compute policy (href: {compute_policy_href})"
f" from org VDC (vdc id: {ovdc_id})",
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
org_href=org.href)
task_href = task_resource.get('href')
request_context.is_async = True
self._remove_compute_policy_from_vdc_async(
request_context=request_context,
task=task,
task_href=task_href,
user_href=user_href,
org_href=org.href,
ovdc_id=ovdc_id,
compute_policy_href=compute_policy_href,
remove_compute_policy_from_vms=remove_compute_policy_from_vms)
return {'task_href': task_href}
def _remove_compute_policy_from_vdc_async(self,
*args,
ovdc_id,
compute_policy_href,
task_resource,
force=False):
vdc = vcd_utils.get_vdc(self._sysadmin_client,
vdc_id=ovdc_id,
is_admin_operation=True)
task_href = task_resource.get('href')
user_href = task_resource.User.get('href')
org_href = task_resource.Organization.get('href')
task = Task(client=self._sysadmin_client)
try:
self.remove_compute_policy_from_vdc_sync(
vdc=vdc,
compute_policy_href=compute_policy_href,
task_resource=task_resource,
force=force)
task.update(
status=vcd_client.TaskStatus.SUCCESS.value,
namespace='vcloud.cse',
operation=f"Removed compute policy (href: "
f"{compute_policy_href}) from org VDC '{vdc.name}'", # noqa: E501
operation_name='Updating VDC',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=self._session.get('user'),
task_href=task_href,
org_href=org_href,
)
except Exception as err:
msg = f'Failed to remove compute policy: {compute_policy_href} ' \
f'from the OVDC: {vdc.name}'
logger.SERVER_LOGGER.error(msg) # noqa: E501
task.update(status=vcd_client.TaskStatus.ERROR.value,
namespace='vcloud.cse',
operation=msg,
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=self._session.get('user'),
task_href=task_href,
org_href=org_href,
error_message=f"{err}",
stack_trace='')
def remove_compute_policy_from_vdc(self, ovdc_id, compute_policy_href,
remove_compute_policy_from_vms=False):
"""Delete the compute policy from the specified vdc.
:param str ovdc_id: id of the vdc to assign the policy
:param compute_policy_href: policy href to remove
:param bool remove_compute_policy_from_vms: If True, will set affected
VMs' compute policy to 'System Default'
:return: dictionary containing 'task_href'.
"""
vdc = pyvcd_utils.get_vdc(self._vcd_client, vdc_id=ovdc_id)
# TODO is there no better way to get the client href?
org = pyvcd_utils.get_org(self._vcd_client)
org.reload()
user_name = self._session.get('user')
user_href = org.get_user(user_name).get('href')
task = Task(self._vcd_client)
task_resource = task.update(
status=TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=f"Removing compute policy (href: {compute_policy_href})"
f" from org VDC (vdc id: {ovdc_id})",
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
org_href=org.href)
task_href = task_resource.get('href')
self._remove_compute_policy_from_vdc_async(
task=task,
task_href=task_href,
user_href=user_href,
org_href=org.href,
ovdc_id=ovdc_id,
compute_policy_href=compute_policy_href,
remove_compute_policy_from_vms=remove_compute_policy_from_vms)
return {
'task_href': task_href
}
def remove_vdc_compute_policy_from_vdc(
self, # noqa: E501
ovdc_id,
compute_policy_href,
force=False): # noqa: E501
"""Delete the compute policy from the specified vdc.
:param str ovdc_id: id of the vdc to assign the policy
:param compute_policy_href: policy href to remove
:param bool force: If True, will set affected
VMs' compute policy to 'System Default'
:return: dictionary containing 'task_href'.
"""
vdc = vcd_utils.get_vdc(self._sysadmin_client, vdc_id=ovdc_id)
# TODO the following org will be associated with 'System' org.
# task created should be associated with the corresponding org of the
# vdc object.
org = vcd_utils.get_org(self._sysadmin_client)
org.reload()
user_name = self._session.get('user')
user_href = org.get_user(user_name).get('href')
task = Task(self._sysadmin_client)
task_resource = task.update(
status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=f"Removing compute policy (href: {compute_policy_href})"
f" from org VDC (vdc id: {ovdc_id})",
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
org_href=org.href)
task_href = task_resource.get('href')
self._remove_compute_policy_from_vdc_async(
ovdc_id=ovdc_id,
compute_policy_href=compute_policy_href,
task_resource=task_resource,
force=force)
return {'task_href': task_href}
def _update_task(self,
status,
message='',
error_message=None,
stack_trace=''):
"""Update task or create it if it does not exist.
This function should only be used in the x_async functions, or in the
6 common broker functions to create the required task.
When this function is used, it logs in the sys admin client if it is
not already logged in, but it does not log out. This is because many
_update_task() calls are used in sequence until the task succeeds or
fails. Once the task is updated to a success or failure state, then
the sys admin client should be logged out.
Another reason for decoupling sys admin logout and this function is
because if any unknown errors occur during an operation, there should
be a finally clause that takes care of logging out.
"""
if not self.tenant_client.is_sysadmin():
stack_trace = ''
if self.task is None:
self.task = Task(self.sys_admin_client)
task_href = None
if self.task_resource is not None:
task_href = self.task_resource.get('href')
org = vcd_utils.get_org(self.tenant_client)
user_href = org.get_user(self.client_session.get('user')).get('href')
self.task_resource = self.task.update(
status=status.value,
namespace='vcloud.cse',
operation=message,
operation_name='cluster operation',
details='',
progress=None,
owner_href=self.tenant_org_href,
owner_name=self.tenant_org_name,
owner_type='application/vnd.vmware.vcloud.org+xml',
user_href=user_href,
user_name=self.tenant_user_name,
org_href=self.tenant_org_href,
task_href=task_href,
error_message=error_message,
stack_trace=stack_trace)
def list_tasks(ctx, status):
try:
client = ctx.obj['client']
task_obj = Task(client)
records = task_obj.list_tasks(filter_status_list=status)
result = []
for r in records:
result.append(
to_dict(r,
attributes=[
'name', 'status', 'objectName', 'ownerName',
'orgName', 'startDate', 'serviceNamespace', 'id'
]))
stdout(result, ctx, show_id=True)
except Exception as e:
stderr(e, ctx)
def update_task(self, status, operation, message=None, error_message=None):
if not hasattr(self, 'task'):
self.task = Task(self.client_sysadmin)
if message is None:
message = OP_MESSAGE[operation]
if hasattr(self, 't'):
task_href = self.t.get('href')
else:
task_href = None
self.t = self.task.update(status.value,
'vcloud.cse',
message,
operation,
'',
None,
'urn:cse:cluster:%s' % self.cluster_id,
self.cluster_name,
'application/vcloud.cse.cluster+xml',
self.tenant_info['user_id'],
self.tenant_info['user_name'],
org_href=self.tenant_info['org_href'],
task_href=task_href,
error_message=error_message)
def remove_compute_policy_from_vdc_sync(self,
vdc,
compute_policy_href,
force=False,
is_placement_policy=False,
task_resource=None):
"""Remove compute policy from vdc.
This method makes use of an umbrella task which can be used for
tracking progress. If the umbrella task is not specified, it is
created.
:param pyvcloud.vcd.vdc.VDC vdc: VDC object
:param str compute_policy_href: href of the compute policy to remove
:param bool force: Force remove compute policy from vms in the VDC
as well
:param lxml.objectify.Element task_resource: Task resource for
the umbrella task
"""
user_name = self._session.get('user')
task = Task(self._sysadmin_client)
task_href = None
is_umbrella_task = task_resource is not None
# Create a task if not umbrella task
if not is_umbrella_task:
# TODO the following org will be associated with 'System' org.
# task created should be associated with the corresponding org of
# the vdc object.
org = vcd_utils.get_org(self._sysadmin_client)
org.reload()
user_href = org.get_user(user_name).get('href')
org_href = org.href
task_resource = task.update(
status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=
f"Removing compute policy (href: {compute_policy_href})" # noqa: E501
f" from org VDC (vdc id: {vdc.name})",
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
org_href=org.href)
else:
user_href = task_resource.User.get('href')
org_href = task_resource.Organization.get('href')
task_href = task_resource.get('href')
try:
# remove the compute policy from VMs if force is True
if force:
compute_policy_id = retrieve_compute_policy_id_from_href(
compute_policy_href) # noqa: E501
vdc_id = vcd_utils.extract_id(vdc.get_resource().get('id'))
vapps = vcd_utils.get_all_vapps_in_ovdc(
client=self._sysadmin_client, ovdc_id=vdc_id)
target_vms = []
system_default_href = None
operation_msg = None
for cp_dict in self.list_compute_policies_on_vdc(vdc_id):
if cp_dict['name'] == _SYSTEM_DEFAULT_COMPUTE_POLICY:
system_default_href = cp_dict['href']
break
if is_placement_policy:
for vapp in vapps:
target_vms += \
[vm for vm in vapp.get_all_vms()
if self._get_vm_placement_policy_id(vm) == compute_policy_id] # noqa: E501
vm_names = [vm.get('name') for vm in target_vms]
operation_msg = f"Removing placement policy from " \
f"{len(vm_names)} VMs. " \
f"Affected VMs: {vm_names}"
else:
for vapp in vapps:
target_vms += \
[vm for vm in vapp.get_all_vms()
if self._get_vm_sizing_policy_id(vm) == compute_policy_id] # noqa: E501
vm_names = [vm.get('name') for vm in target_vms]
operation_msg = "Setting sizing policy to " \
f"'{_SYSTEM_DEFAULT_COMPUTE_POLICY}' on " \
f"{len(vm_names)} VMs. " \
f"Affected VMs: {vm_names}"
task.update(status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=operation_msg,
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
task_href=task_href,
org_href=org_href)
task_monitor = self._sysadmin_client.get_task_monitor()
for vm_resource in target_vms:
vm = VM(self._sysadmin_client,
href=vm_resource.get('href'))
_task = None
operation_msg = None
if is_placement_policy:
if hasattr(vm_resource, 'ComputePolicy') and \
not hasattr(vm_resource.ComputePolicy, 'VmSizingPolicy'): # noqa: E501
# Updating sizing policy for the VM
_task = vm.update_compute_policy(
compute_policy_href=system_default_href)
operation_msg = \
"Setting compute policy to " \
f"'{_SYSTEM_DEFAULT_COMPUTE_POLICY}' "\
f"on VM '{vm_resource.get('name')}'"
task.update(
status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=operation_msg,
operation_name=
f'Setting sizing policy to {_SYSTEM_DEFAULT_COMPUTE_POLICY}', # noqa: E501
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
task_href=task_href,
org_href=org_href)
task_monitor.wait_for_success(_task)
_task = vm.remove_placement_policy()
operation_msg = "Removing placement policy on VM " \
f"'{vm_resource.get('name')}'"
task.update(
status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=operation_msg,
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
task_href=task_href,
org_href=org_href)
task_monitor.wait_for_success(_task)
else:
_task = vm.update_compute_policy(
compute_policy_href=system_default_href)
operation_msg = "Setting sizing policy to " \
f"'{_SYSTEM_DEFAULT_COMPUTE_POLICY}' "\
f"on VM '{vm_resource.get('name')}'"
task.update(
status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=operation_msg,
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
task_href=task_href,
org_href=org_href)
task_monitor.wait_for_success(_task)
final_status = vcd_client.TaskStatus.RUNNING.value \
if is_umbrella_task else vcd_client.TaskStatus.SUCCESS.value
task.update(status=final_status,
namespace='vcloud.cse',
operation=f"Removing compute policy (href:"
f"{compute_policy_href}) from org VDC '{vdc.name}'",
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=user_name,
task_href=task_href,
org_href=org_href)
vdc.remove_compute_policy(compute_policy_href)
except Exception as err:
logger.SERVER_LOGGER.error(err, exc_info=True)
# Set task to error if not an umbrella task
if not is_umbrella_task:
msg = 'Failed to remove compute policy: ' \
f'{compute_policy_href} from the OVDC: {vdc.name}'
task.update(status=vcd_client.TaskStatus.ERROR.value,
namespace='vcloud.cse',
operation=msg,
operation_name='Remove org VDC compute policy',
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=self._session.get('user'),
task_href=task_href,
org_href=org_href,
error_message=f"{err}",
stack_trace='')
raise err
def _reload_templates_async(op_ctx, task_href):
user_context = None
task = None
user_href = None
try:
user_context = op_ctx.get_user_context(api_version=None)
user_client = user_context.client
org = vcd_utils.get_org(user_client, user_context.org_name)
user_href = org.get_user(user_context.name).get('href')
task = Task(user_client)
server_config = server_utils.get_server_runtime_config()
if not server_utils.is_no_vc_communication_mode():
native_templates = \
template_reader.read_native_template_definition_from_catalog(
config=server_config
)
server_config.set_value_at('broker.templates', native_templates)
task.update(status=TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation="Finished reloading native templates.",
operation_name='template reload',
details='',
progress=None,
owner_href=user_context.org_href,
owner_name=user_context.org_name,
owner_type='application/vnd.vmware.vcloud.org+xml',
user_href=user_href,
user_name=user_context.name,
org_href=user_context.org_href,
task_href=task_href)
else:
msg = "Skipping loading k8s template definition from catalog " \
"since `No communication with VCenter` mode is on."
logger.SERVER_LOGGER.info(msg)
server_config.set_value_at('broker.templates', [])
task.update(status=TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=msg,
operation_name='template reload',
details='',
progress=None,
owner_href=user_context.org_href,
owner_name=user_context.org_name,
owner_type='application/vnd.vmware.vcloud.org+xml',
user_href=user_href,
user_name=user_context.name,
org_href=user_context.org_href,
task_href=task_href)
task.update(status=TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation="Reloading TKG templates.",
operation_name='template reload',
details='',
progress=None,
owner_href=user_context.org_href,
owner_name=user_context.org_name,
owner_type='application/vnd.vmware.vcloud.org+xml',
user_href=user_href,
user_name=user_context.name,
org_href=user_context.org_href,
task_href=task_href)
tkgm_templates = \
template_reader.read_tkgm_template_definition_from_catalog(
config=server_config
)
server_config.set_value_at('broker.tkgm_templates', tkgm_templates)
task.update(status=TaskStatus.SUCCESS.value,
namespace='vcloud.cse',
operation="Finished reloading all templates.",
operation_name='template reload',
details='',
progress=None,
owner_href=user_context.org_href,
owner_name=user_context.org_name,
owner_type='application/vnd.vmware.vcloud.org+xml',
user_href=user_href,
user_name=user_context.name,
org_href=user_context.org_href,
task_href=task_href)
except Exception:
msg = "Error reloading templates."
logger.SERVER_LOGGER.error(msg, exc_info=True)
if task and user_context and user_href:
task.update(status=TaskStatus.ERROR.value,
namespace='vcloud.cse',
operation=msg,
operation_name='template reload',
details='',
progress=None,
owner_href=user_context.org_href,
owner_name=user_context.org_name,
owner_type='application/vnd.vmware.vcloud.org+xml',
user_href=user_href,
user_name=user_context.name,
org_href=user_context.org_href,
task_href=task_href)
finally:
op_ctx.end()