def test_0002_add_vm(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert vapp_resource.get('name') == self.config['vcd']['vapp']
vapp = VApp(self.client, resource=vapp_resource)
catalog_item = org.get_catalog_item(self.config['vcd']['catalog'],
self.config['vcd']['template'])
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
spec = {'source_vm_name': self.config['vcd']['vm'],
'vapp': source_vapp_resource}
spec['target_vm_name'] = self.config['vcd']['hostname']
spec['hostname'] = self.config['vcd']['hostname']
spec['network'] = self.config['vcd']['network']
spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode']
spec['storage_profile'] = vdc.get_storage_profile(
self.config['vcd']['storage_profile'])
vms = [spec]
result = vapp.add_vms(vms)
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def add_vm(ctx, name, source_vapp, source_vm, catalog, target_vm, hostname,
network, ip_allocation_mode, storage_profile, password_auto,
accept_all_eulas):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
source_vapp_resource = None
if catalog is None:
source_vapp_resource = vdc.get_vapp(source_vapp)
else:
catalog_item = org.get_catalog_item(catalog, source_vapp)
source_vapp_resource = client.get_resource(
catalog_item.Entity.get('href'))
assert source_vapp_resource is not None
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
spec = {'source_vm_name': source_vm, 'vapp': source_vapp_resource}
if target_vm is not None:
spec['target_vm_name'] = target_vm
if hostname is not None:
spec['hostname'] = hostname
if network is not None:
spec['network'] = network
spec['ip_allocation_mode'] = ip_allocation_mode
if storage_profile is not None:
spec['storage_profile'] = vdc.get_storage_profile(storage_profile)
if password_auto is not None:
spec['password_auto'] = password_auto
task = vapp.add_vms([spec], all_eulas_accepted=accept_all_eulas)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def test_0002_add_vm(self):
org_resource = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
self.logger.debug('org: %s' % org_resource.get('name'))
org = Org(self.client, href=org_resource.get('href'))
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert vapp_resource.get('name') == self.config['vcd']['vapp']
vapp = VApp(self.client, resource=vapp_resource)
catalog_item = org.get_catalog_item(self.config['vcd']['catalog'],
self.config['vcd']['template'])
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
spec = {
'source_vm_name': self.config['vcd']['vm'],
'vapp': source_vapp_resource
}
spec['target_vm_name'] = self.config['vcd']['hostname']
spec['hostname'] = self.config['vcd']['hostname']
spec['network'] = self.config['vcd']['network']
spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode']
spec['storage_profile'] = vdc.get_storage_profile(
self.config['vcd']['storage_profile'])
vms = [spec]
result = vapp.add_vms(vms, all_eulas_accepted=True)
task = self.client.get_task_monitor().wait_for_status(task=result)
assert task.get('status') == TaskStatus.SUCCESS.value
def create_from_vapp(self, request):
logging.info("__INIT__create[VappVm] source_catalog_name[%s]",
request.source_vapp)
res = vapp_vm_pb2.CreateVappVmResult()
res.created = False
source_vapp_resource = self.get_vapp_resource(
request.target_vdc, vapp_name=request.source_vapp)
target_vapp_resource = self.get_vapp_resource(
request.target_vdc, vapp_name=request.target_vapp)
specs = [{
'vapp': source_vapp_resource,
'source_vm_name': request.source_vm_name,
'target_vm_name': request.target_vm_name,
'hostname': request.hostname,
'password': request.password,
'password_auto': request.password_auto,
'password_reset': request.password_reset,
'cust_script': request.cust_script,
'network': request.network,
# 'storage_profile': request.storage_profile
}]
try:
vapp = VApp(self.client, resource=target_vapp_resource)
create_vapp_vm_resp = vapp.add_vms(
specs,
power_on=request.power_on,
all_eulas_accepted=request.all_eulas_accepted)
task_monitor = self.client.get_task_monitor()
task = task_monitor.wait_for_status(
task=create_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st != TaskStatus.SUCCESS.value:
raise errors.VappVmCreateError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
res.created = True
except Exception as e:
errmsg = '''__ERROR_create[VappVm] failed for vm {0}. __ErrorMessage__ {1}'''
logging.warn(errmsg.format(request.target_vm_name, str(e)))
self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
self.context.set_details(errmsg)
return res
logging.info("__DONE__create[VappVm]")
return res
def create_from_vapp(self, request):
logging.info(
"__INIT__create[VappVm] source_catalog_name[%s]", request.source_vapp)
res = vapp_vm_pb2.CreateVappVmResult()
res.created = False
source_vapp_resource = self.get_vapp_resource(
request.target_vdc, vapp_name=request.source_vapp)
target_vapp_resource = self.get_vapp_resource(
request.target_vdc, vapp_name=request.target_vapp)
specs = [{
'vapp': source_vapp_resource,
'source_vm_name': request.source_vm_name,
'target_vm_name': request.target_vm_name,
'hostname': request.hostname,
'password': request.password,
'password_auto': request.password_auto,
'password_reset': request.password_reset,
'cust_script': request.cust_script,
'network': request.network,
# 'storage_profile': request.storage_profile
}]
try:
vapp = VApp(self.client, resource=target_vapp_resource)
create_vapp_vm_resp = vapp.add_vms(specs,
power_on=request.power_on,
all_eulas_accepted=request.all_eulas_accepted)
task_monitor = self.client.get_task_monitor()
task = task_monitor.wait_for_status(
task=create_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st != TaskStatus.SUCCESS.value:
raise errors.VappVmCreateError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
res.created = True
except Exception as e:
errmsg = '''__ERROR_create[VappVm] failed for vm {0}. __ErrorMessage__ {1}'''
logging.warn(errmsg.format(request.target_vm_name, str(e)))
self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
self.context.set_details(errmsg)
return res
logging.info("__DONE__create[VappVm]")
return res
def _clone(self, source_vapp_name, target_vapp_name, target_vm_name,
source_delete):
"""Clone VM from one vApp to another.
:param: str source vApp name
:param: str target vApp name
:param: str target VM name
:param: bool source delete option
:return: an object containing EntityType.TASK XML data which represents
the asynchronous task that is copying VM
:rtype: lxml.objectify.ObjectifiedElement
"""
from pyvcloud.vcd.vapp import VApp
vm_resource = self.get_resource()
resource_type = ResourceType.VAPP.value
if self.is_powered_off(vm_resource) or source_delete:
records1 = self.___validate_vapp_records(
vapp_name=source_vapp_name, resource_type=resource_type)
source_vapp_href = records1[0].get('href')
records2 = self.___validate_vapp_records(
vapp_name=target_vapp_name, resource_type=resource_type)
target_vapp_href = records2[0].get('href')
source_vapp = VApp(self.client, href=source_vapp_href)
target_vapp = VApp(self.client, href=target_vapp_href)
target_vapp.reload()
spec = {
'vapp': source_vapp.get_resource(),
'source_vm_name': self.get_resource().get('name'),
'target_vm_name': target_vm_name
}
return target_vapp.add_vms([spec],
deploy=False,
power_on=False,
all_eulas_accepted=True,
source_delete=source_delete
)
else:
raise InvalidStateException("VM Must be powered off.")
def copy_to(self, source_vapp_name, target_vapp_name, target_vm_name):
"""Copy VM from one vApp to another.
:param: str source vApp name
:param: str target vApp name
:param: str target VM name
:return: an object containing EntityType.TASK XML data which represents
the asynchronous task that is copying VM
:rtype: lxml.objectify.ObjectifiedElement
"""
from pyvcloud.vcd.vapp import VApp
vm_resource = self.get_resource()
resource_type = ResourceType.VAPP.value
if self.is_powered_off(vm_resource):
records1 = self.___validate_vapp_records(
vapp_name=source_vapp_name, resource_type=resource_type)
source_vapp_href = records1[0].get('href')
records2 = self.___validate_vapp_records(
vapp_name=target_vapp_name, resource_type=resource_type)
target_vapp_href = records2[0].get('href')
source_vapp = VApp(self.client, href=source_vapp_href)
target_vapp = VApp(self.client, href=target_vapp_href)
target_vapp.reload()
spec = {
'vapp': source_vapp.get_resource(),
'source_vm_name': self.get_resource().get('name'),
'target_vm_name': target_vm_name
}
return target_vapp.add_vms([spec],
deploy=False,
power_on=False,
all_eulas_accepted=True
)
else:
raise InvalidStateException("VM Must be powered off.")
def test_0002_add_vm(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert vapp_resource.get('name') == self.config['vcd']['vapp']
vapp = VApp(self.client, resource=vapp_resource)
catalog_item = org.get_catalog_item(self.config['vcd']['catalog'],
self.config['vcd']['template'])
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
spec = {
'source_vm_name': self.config['vcd']['vm'],
'vapp': source_vapp_resource
}
spec['target_vm_name'] = self.config['vcd']['hostname']
spec['hostname'] = self.config['vcd']['hostname']
spec['network'] = self.config['vcd']['network']
spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode']
spec['storage_profile'] = vdc.get_storage_profile(
self.config['vcd']['storage_profile'])
vms = [spec]
result = vapp.add_vms(vms)
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def add_vm(ctx, name, source_vapp, source_vm, catalog, target_vm, hostname,
network, ip_allocation_mode, storage_profile, password_auto,
accept_all_eulas):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
source_vapp_resource = None
if catalog is None:
source_vapp_resource = vdc.get_vapp(source_vapp)
else:
catalog_item = org.get_catalog_item(catalog, source_vapp)
source_vapp_resource = client.get_resource(
catalog_item.Entity.get('href'))
assert source_vapp_resource is not None
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
spec = {'source_vm_name': source_vm, 'vapp': source_vapp_resource}
if target_vm is not None:
spec['target_vm_name'] = target_vm
if hostname is not None:
spec['hostname'] = hostname
if network is not None:
spec['network'] = network
spec['ip_allocation_mode'] = ip_allocation_mode
if storage_profile is not None:
spec['storage_profile'] = vdc.get_storage_profile(storage_profile)
if password_auto is not None:
spec['password_auto'] = password_auto
task = vapp.add_vms([spec], all_eulas_accepted=accept_all_eulas)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def create_from_catalog(self, request):
logging.info("__INIT__create[VappVm] source_catalog_name[%s]",
request.source_catalog_name)
res = vapp_vm_pb2.CreateVappVmResult()
res.created = False
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
try:
vdc_resource = org.get_vdc(request.target_vdc)
vdc = VDC(
self.client, name=request.target_vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(request.target_vapp)
vapp = VApp(
self.client, name=request.target_vapp, resource=vapp_resource)
catalog_item = org.get_catalog_item(request.source_catalog_name,
request.source_template_name)
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
specs = [{
'source_vm_name': request.source_vm_name,
'vapp': source_vapp_resource,
'target_vm_name': request.target_vm_name,
'hostname': request.hostname,
'network': request.network,
'ip_allocation_mode': request.ip_allocation_mode,
# 'storage_profile': request.storage_profile
}]
create_vapp_vm_resp = vapp.add_vms(
specs,
power_on=request.power_on,
all_eulas_accepted=request.all_eulas_accepted)
task_monitor = self.client.get_task_monitor()
task = task_monitor.wait_for_status(
task=create_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st != TaskStatus.SUCCESS.value:
raise errors.VappVmCreateError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
res.created = True
except Exception as e:
errmsg = '''__ERROR_create[VappVm] failed for vm {0}. __ErrorMessage__ {1}'''
logging.warn(errmsg.format(request.target_vm_name, str(e)))
self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
self.context.set_details(errmsg)
return res
logging.info("__DONE__create[VappVm]")
return res
class VappVM(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VappVM, self).__init__(**kwargs)
vapp_resource = self.get_target_resource()
self.vapp = VApp(self.client, resource=vapp_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.add_vm()
if state == "absent":
return self.delete_vm()
if state == "update":
return self.update_vm()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "poweron":
return self.power_on_vm()
if operation == "poweroff":
return self.power_off_vm()
if operation == "reloadvm":
return self.reload_vm()
if operation == "deploy":
return self.deploy_vm()
if operation == "undeploy":
return self.undeploy_vm()
if operation == "list_disks":
return self.list_disks()
if operation == "list_nics":
return self.list_nics()
def get_source_resource(self):
source_catalog_name = self.params.get('source_catalog_name')
source_template_name = self.params.get('source_template_name')
source_vdc = self.params.get('source_vdc')
source_vapp = self.params.get('source_vapp')
org_resource = Org(self.client, resource=self.client.get_org())
source_vapp_resource = None
if source_vapp:
source_vdc_resource = VDC(
self.client, resource=org_resource.get_vdc(source_vdc))
source_vapp_resource_href = source_vdc_resource.get_resource_href(
name=source_vapp, entity_type=EntityType.VAPP)
source_vapp_resource = self.client.get_resource(
source_vapp_resource_href)
if source_catalog_name:
catalog_item = org_resource.get_catalog_item(
source_catalog_name, source_template_name)
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
return source_vapp_resource
def get_target_resource(self):
target_vapp = self.params.get('target_vapp')
target_vdc = self.params.get('target_vdc')
org_resource = Org(self.client, resource=self.client.get_org())
target_vapp_resource = None
target_vdc_resource = VDC(
self.client, resource=org_resource.get_vdc(target_vdc))
target_vapp_resource = target_vdc_resource.get_vapp(target_vapp)
return target_vapp_resource
def get_storage_profile(self, profile_name):
target_vdc = self.params.get('target_vdc')
org_resource = Org(self.client, resource=self.client.get_org())
vdc_resource = VDC(
self.client, resource=org_resource.get_vdc(target_vdc))
return vdc_resource.get_storage_profile(profile_name)
def get_vm(self):
vapp_vm_resource = self.vapp.get_vm(self.params.get('target_vm_name'))
return VM(self.client, resource=vapp_vm_resource)
def add_vm(self):
params = self.params
source_vapp_resource = self.get_source_resource()
target_vm_name = params.get('target_vm_name')
source_vm_name = params.get('source_vm_name')
hostname = params.get('hostname')
vmpassword = params.get('vmpassword')
vmpassword_auto = params.get('vmpassword_auto')
vmpassword_reset = params.get('vmpassword_reset')
network = params.get('network')
all_eulas_accepted = params.get('all_eulas_accepted')
power_on = params.get('power_on')
deploy = params.get('deploy')
ip_allocation_mode = params.get('ip_allocation_mode')
cust_script = params.get('cust_script')
storage_profile = params.get('storage_profile')
response = dict()
response['changed'] = False
try:
self.get_vm()
except EntityNotFoundException:
spec = {
'source_vm_name': source_vm_name,
'vapp': source_vapp_resource,
'target_vm_name': target_vm_name,
'hostname': hostname,
'password': vmpassword,
'password_auto': vmpassword_auto,
'password_reset': vmpassword_reset,
'ip_allocation_mode': ip_allocation_mode,
'network': network,
'cust_script': cust_script
}
spec = {k: v for k, v in spec.items() if v}
if storage_profile:
spec['storage_profile'] = self.get_storage_profile(storage_profile)
specs = [spec]
args = {
"specs": specs,
"deploy": deploy,
"power_on": power_on,
"all_eulas_accepted": all_eulas_accepted
}
add_vms_task = self.vapp.add_vms(**args)
self.execute_task(add_vms_task)
response['msg'] = 'VM {} has been created.'.format(target_vm_name)
response['changed'] = True
else:
msg = 'VM {} is already present.'
response['warnings'] = msg.format(target_vm_name)
return response
def delete_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
except EntityNotFoundException:
response['warnings'] = 'VM {} is not present.'.format(vm_name)
else:
if not vm.is_powered_off():
self.undeploy_vm()
delete_vms_task = self.vapp.delete_vms([vm_name])
self.execute_task(delete_vms_task)
response['msg'] = 'VM {} has been deleted.'.format(vm_name)
response['changed'] = True
return response
def update_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
if self.params.get("virtual_cpus"):
self.update_vm_cpu()
response['changed'] = True
if self.params.get("memory"):
self.update_vm_memory()
response['changed'] = True
response['msg'] = 'VM {} has been updated.'.format(vm_name)
return response
def update_vm_cpu(self):
virtual_cpus = self.params.get('virtual_cpus')
cores_per_socket = self.params.get('cores_per_socket')
vm = self.get_vm()
update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket)
return self.execute_task(update_cpu_task)
def update_vm_memory(self):
memory = self.params.get('memory')
vm = self.get_vm()
update_memory_task = vm.modify_memory(memory)
return self.execute_task(update_memory_task)
def power_on_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
vm = self.get_vm()
if not vm.is_powered_on():
self.deploy_vm()
response['msg'] = 'VM {} has been powered on.'.format(vm_name)
response['changed'] = True
else:
response['warnings'] = 'VM {} is powered on.'.format(vm_name)
return response
def power_off_vm(self,):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
vm = self.get_vm()
if not vm.is_powered_off():
self.undeploy_vm()
response['msg'] = 'VM {} has been powered off.'.format(vm_name)
response['changed'] = True
else:
response['warnings'] = 'VM {} is powered off.'.format(vm_name)
return response
def reload_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
vm = self.get_vm()
vm.reload()
response['msg'] = 'VM {} has been reloaded.'.format(vm_name)
response['changed'] = True
return response
def deploy_vm(self):
vm_name = self.params.get('target_vm_name')
force_customization = self.params.get('force_customization')
response = dict()
response['changed'] = False
vm = self.get_vm()
if not vm.is_deployed():
deploy_vm_task = vm.deploy(force_customization=force_customization)
self.execute_task(deploy_vm_task)
msg = 'VM {} has been deployed'
response['msg'] = msg.format(vm_name)
response['changed'] = True
else:
msg = 'VM {} is already deployed'
response['warnings'] = msg.format(vm_name)
return response
def undeploy_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
vm = self.get_vm()
if not vm.is_deployed():
undeploy_vm_task = vm.undeploy(action="powerOff")
self.execute_task(undeploy_vm_task)
msg = 'VM {} has been undeployed'
response['msg'] = msg.format(vm_name)
response['changed'] = True
else:
msg = 'VM {} is already undeployed'
response['warnings'] = msg.format(vm_name)
return response
def list_disks(self):
response = dict()
response['changed'] = False
response['msg'] = list()
vm = self.get_vm()
response['msg'] = vm.list_virtual_hardware_section(
is_cpu=False, is_memory=False, is_disk=True)
return response
def list_nics(self):
response = dict()
response['changed'] = False
response['msg'] = list()
vm = self.get_vm()
response['msg'] = vm.list_nics()
return response
def create(client):
print("=============== __LOG__Create_VDC =======================\n\n")
vdc_name = "ACME_PAYG"
vapp_name = "test2"
org_resource = client.get_org()
org = Org(client, resource=org_resource)
print("Org name: ", org.get_name())
print("Vdc name: ", vdc_name)
try:
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, name=vdc_name, resource=vdc_resource)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, name=vapp_name, resource=vapp_resource)
print("vapp : ", vapp)
catalog_item = org.get_catalog_item('ACME', 'tinyova')
source_vapp_resource = client.get_resource(
catalog_item.Entity.get('href'))
print("source_vapp_resource: ", source_vapp_resource)
spec = {
'source_vm_name': 'Tiny Linux template',
'vapp': source_vapp_resource
}
storage_profiles = [{
'name': 'Performance',
'enabled': True,
'units': 'MB',
'limit': 0,
'default': True
}]
spec['target_vm_name'] = 'ubuntu_pcp_11'
spec['hostname'] = 'ubuntu'
spec['network'] = 'global'
spec['ip_allocation_mode'] = 'dhcp'
#spec['storage_profile'] = storage_profiles
vms = [spec]
result = vapp.add_vms(vms)
print("result: ", result)
#task = client.get_task_monitor().wait_for_status(
# task=result,
# timeout=60,
# poll_frequency=2,
# fail_on_statuses=None,
# expected_target_statuses=[
# TaskStatus.SUCCESS,
# TaskStatus.ABORTED,
# TaskStatus.ERROR,
# TaskStatus.CANCELED],
# callback=None)
#st = task.get('status')
#if st == TaskStatus.SUCCESS.value:
# message = 'status : {0} '.format(st)
# logging.info(message)
#else:
# print("st : ", st)
# raise Exception(task)
print("=============================================\n\n")
return True
except Exception as e:
error_message = '__ERROR_ [create_vdc] failed for vdc {0} '.format(
vdc_name)
logging.warn(error_message, e)
return False
vms = []
for vm_cfg in cfg.vapp['vms']:
print(vm_cfg)
source_vapp_resource = client.get_resource(catalog_item.Entity.get('href'))
create_master_vm(vms, source_vapp_resource, vm_cfg)
# wait for the master to start and get the first ip
time.sleep(15)
for vm_slave_cfg in vm_cfg['slaves']:
source_slave_vapp_resource = client.get_resource(
catalog_item.Entity.get('href'))
create_slave_vm(vms, vm_cfg['name'], source_slave_vapp_resource,
vm_slave_cfg)
print("Creating (if needed) ...")
result = vapp.add_vms(vms)
handle_task(client, result)
print("Statuses ...")
while (vapp.get_all_vms() is None
or len(vapp.get_all_vms()) < len(cfg.vapp['vms'])):
print(" VMs ... {0}\r".format("waiting full start ...".ljust(20)), end='')
vapp.reload()
for vm in vapp.get_all_vms():
vm_obj = VM(client, resource=vm)
while (vm_obj.is_powered_on() == False):
print(" VM '{0}' ... {1}\r".format(vm.get('name'),
"DOWN (waiting)".ljust(20)),
end='')
vm_obj.reload()
def create(client):
print("=============== __LOG__Create_VDC =======================\n\n")
vdc_name = "ACME_PAYG"
vapp_name = "test2"
org_resource = client.get_org()
org = Org(client, resource=org_resource)
print("Org name: ", org.get_name())
print("Vdc name: ", vdc_name)
try:
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, name=vdc_name, resource=vdc_resource)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, name=vapp_name, resource=vapp_resource)
print("vapp : ", vapp)
catalog_item = org.get_catalog_item('ACME', 'tinyova')
source_vapp_resource = client.get_resource(
catalog_item.Entity.get('href'))
print("source_vapp_resource: ", source_vapp_resource)
spec = {
'source_vm_name': 'Tiny Linux template',
'vapp': source_vapp_resource
}
storage_profiles = [{
'name': 'Performance',
'enabled': True,
'units': 'MB',
'limit': 0,
'default': True
}]
spec['target_vm_name'] = 'ubuntu_pcp_11'
spec['hostname'] = 'ubuntu'
spec['network'] = 'global'
spec['ip_allocation_mode'] = 'dhcp'
#spec['storage_profile'] = storage_profiles
vms = [spec]
result = vapp.add_vms(vms)
print("result: ", result)
#task = client.get_task_monitor().wait_for_status(
# task=result,
# timeout=60,
# poll_frequency=2,
# fail_on_statuses=None,
# expected_target_statuses=[
# TaskStatus.SUCCESS,
# TaskStatus.ABORTED,
# TaskStatus.ERROR,
# TaskStatus.CANCELED],
# callback=None)
#st = task.get('status')
#if st == TaskStatus.SUCCESS.value:
# message = 'status : {0} '.format(st)
# logging.info(message)
#else:
# print("st : ", st)
# raise Exception(task)
print("=============================================\n\n")
return True
except Exception as e:
error_message = '__ERROR_ [create_vdc] failed for vdc {0} '.format(
vdc_name)
logging.warn(error_message, e)
return False
class VappVM(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VappVM, self).__init__(**kwargs)
vapp_resource = self.get_target_resource()
self.vapp = VApp(self.client, resource=vapp_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.add_vm()
if state == "absent":
return self.delete_vm()
if state == "update":
return self.update_vm()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "poweron":
return self.power_on_vm()
if operation == "poweroff":
return self.power_off_vm()
if operation == "reloadvm":
return self.reload_vm()
if operation == "deploy":
return self.deploy_vm()
if operation == "undeploy":
return self.undeploy_vm()
def get_source_resource(self):
source_catalog_name = self.params.get('source_catalog_name')
source_template_name = self.params.get('source_template_name')
source_vdc = self.params.get('source_vdc')
source_vapp = self.params.get('source_vapp')
org_resource = Org(self.client, resource=self.client.get_org())
source_vapp_resource = None
if source_vapp:
source_vdc_resource = VDC(
self.client, resource=org_resource.get_vdc(source_vdc))
source_vapp_resource_href = source_vdc_resource.get_resource_href(
name=source_vapp, entity_type=EntityType.VAPP)
source_vapp_resource = self.client.get_resource(
source_vapp_resource_href)
if source_catalog_name:
catalog_item = org_resource.get_catalog_item(
source_catalog_name, source_template_name)
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
return source_vapp_resource
def get_target_resource(self):
target_vapp = self.params.get('target_vapp')
target_vdc = self.params.get('target_vdc')
org_resource = Org(self.client, resource=self.client.get_org())
target_vapp_resource = None
target_vdc_resource = VDC(self.client,
resource=org_resource.get_vdc(target_vdc))
target_vapp_resource = target_vdc_resource.get_vapp(target_vapp)
return target_vapp_resource
def get_vm(self):
vapp_vm_resource = self.vapp.get_vm(self.params.get('target_vm_name'))
return VM(self.client, resource=vapp_vm_resource)
def add_vm(self):
params = self.params
source_vapp_resource = self.get_source_resource()
target_vm_name = params.get('target_vm_name')
source_vm_name = params.get('source_vm_name')
hostname = params.get('hostname')
vmpassword = params.get('vmpassword')
vmpassword_auto = params.get('vmpassword_auto')
vmpassword_reset = params.get('vmpassword_reset')
network = params.get('network')
all_eulas_accepted = params.get('all_eulas_accepted', True)
power_on = params.get('power_on', True)
ip_allocation_mode = params.get('ip_allocation_mode')
# cust_script = params.get('cust_script')
# storage_profile = params.get('storage_profile')
response = dict()
response['changed'] = False
try:
self.get_vm()
except EntityNotFoundException:
specs = [{
'source_vm_name': source_vm_name,
'vapp': source_vapp_resource,
'target_vm_name': target_vm_name,
'hostname': hostname,
'password': vmpassword,
'password_auto': vmpassword_auto,
'password_reset': vmpassword_reset,
'ip_allocation_mode': ip_allocation_mode,
'network': network,
# 'cust_script': cust_script,
# 'storage_profile': json.loads(storage_profile)
}]
add_vms_task = self.vapp.add_vms(
specs,
power_on=power_on,
all_eulas_accepted=all_eulas_accepted)
self.execute_task(add_vms_task)
response['msg'] = 'Vapp VM {} has been created.'.format(
target_vm_name)
response['changed'] = True
else:
response['msg'] = 'Vapp VM {} is already present.'.format(
target_vm_name)
return response
def delete_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
self.get_vm()
except EntityNotFoundException:
response['msg'] = 'Vapp VM {} is not present.'.format(vm_name)
else:
self.undeploy_vm()
delete_vms_task = self.vapp.delete_vms([vm_name])
self.execute_task(delete_vms_task)
response['msg'] = 'Vapp VM {} has been deleted.'.format(vm_name)
response['changed'] = True
return response
def update_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
if self.params.get("virtual_cpus"):
self.update_vm_cpu()
response['changed'] = True
if self.params.get("memory"):
self.update_vm_memory()
response['changed'] = True
response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name)
return response
def update_vm_cpu(self):
virtual_cpus = self.params.get('virtual_cpus')
cores_per_socket = self.params.get('cores_per_socket')
vm = self.get_vm()
update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket)
return self.execute_task(update_cpu_task)
def update_vm_memory(self):
memory = self.params.get('memory')
vm = self.get_vm()
update_memory_task = vm.modify_memory(memory)
return self.execute_task(update_memory_task)
def power_on_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
power_on_task = vm.power_on()
self.execute_task(power_on_task)
response['msg'] = 'Vapp VM {} has been powered on.'.format(vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['msg'] = 'Vapp VM {} is already powered on.'.format(
vm_name)
return response
def power_off_vm(self, ):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
power_off_task = vm.power_off()
self.execute_task(power_off_task)
response['msg'] = 'Vapp VM {} has been powered off.'.format(
vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['msg'] = 'Vapp VM {} is already powered off.'.format(
vm_name)
return response
def reload_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
vm = self.get_vm()
vm.reload()
response['msg'] = 'Vapp VM {} has been reloaded.'.format(vm_name)
response['changed'] = True
return response
def deploy_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
deploy_vm_task = vm.deploy()
self.execute_task(deploy_vm_task)
response['msg'] = 'Vapp VM {} has been deployed.'.format(vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['msg'] = 'Vapp VM {} is already deployed.'.format(vm_name)
return response
def undeploy_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
undeploy_vm_task = vm.undeploy()
self.execute_task(undeploy_vm_task)
response['msg'] = 'Vapp VM {} has been undeployed.'.format(vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['msg'] = 'Vapp VM {} is already undeployed.'.format(
vm_name)
return response
class VappVM(object):
def __init__(self, module, vapp_resource):
self.module = module
self.vapp = VApp(module.client, resource=vapp_resource)
def execute_task(self, task):
client = self.module.client
task_monitor = client.get_task_monitor()
task_state = task_monitor.wait_for_status(task=task,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
task_status = task_state.get('status')
if task_status != TaskStatus.SUCCESS.value:
raise Exception(etree.tostring(task_state, pretty_print=True))
return 1
def get_vm(self, vm_name):
vapp_vm_resource = self.vapp.get_vm(vm_name)
return VM(self.module.client, resource=vapp_vm_resource)
def add_vms(self, target_vm_name, source_vapp_resource):
params = self.module.params
source_vm_name = params.get('source_vm_name')
hostname = params.get('hostname')
vmpassword = params.get('vmpassword')
vmpassword_auto = params.get('vmpassword_auto')
vmpassword_reset = params.get('vmpassword_reset')
network = params.get('network')
all_eulas_accepted = params.get('all_eulas_accepted', True)
power_on = params.get('power_on', True)
ip_allocation_mode = params.get('ip_allocation_mode')
# cust_script = module.params.get('cust_script')
# storage_profile = module.params.get('storage_profile')
response = dict()
specs = [{
'source_vm_name': source_vm_name,
'vapp': source_vapp_resource,
'target_vm_name': target_vm_name,
'hostname': hostname,
'password': vmpassword,
'password_auto': vmpassword_auto,
'password_reset': vmpassword_reset,
'ip_allocation_mode': ip_allocation_mode,
'network': network,
# 'cust_script': cust_script,
# 'storage_profile': storage_profile
}]
add_vms_task = self.vapp.add_vms(specs,
power_on=power_on,
all_eulas_accepted=all_eulas_accepted)
self.execute_task(add_vms_task)
response['msg'] = 'Vapp VM {} has been created.'.format(target_vm_name)
response['changed'] = True
return response
def delete_vms(self, vm_name):
response = dict()
self.undeploy_vm(vm_name)
delete_vms_task = self.vapp.delete_vms([vm_name])
self.execute_task(delete_vms_task)
response['msg'] = 'Vapp VM {} has been deleted.'.format(vm_name)
response['changed'] = True
return response
def power_on_vm(self, vm_name):
vm = self.get_vm(vm_name)
response = dict()
power_on_task = vm.power_on()
self.execute_task(power_on_task)
response['msg'] = 'Vapp VM {} has been powered on.'.format(vm_name)
response['changed'] = True
return response
def power_off_vm(self, vm_name):
vm = self.get_vm(vm_name)
response = dict()
power_off_task = vm.power_off()
self.execute_task(power_off_task)
response['msg'] = 'Vapp VM {} has been powered off.'.format(vm_name)
response['changed'] = True
return response
def reload_vm(self, vm_name):
vm = self.get_vm(vm_name)
response = dict()
vm.reload()
response['msg'] = 'Vapp VM {} has been reloaded.'.format(vm_name)
response['changed'] = True
return response
def update_cpu_of_vm(self, vm_name):
params = self.module.params
vm = self.get_vm(vm_name)
virtual_cpus = params.get('virtual_cpus')
cores_per_socket = params.get('cores_per_socket')
response = dict()
self.power_off_vm(vm_name)
update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket)
self.execute_task(update_cpu_task)
response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name)
response['changed'] = True
return response
def update_memory_of_vm(self, vm_name):
params = self.module.params
vm = self.get_vm(vm_name)
memory = params.get('memory')
response = dict()
self.power_off_vm(vm_name)
update_memory_task = vm.modify_memory(memory)
self.execute_task(update_memory_task)
response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name)
response['changed'] = True
return response
def deploy_vm(self, vm_name):
vm = self.get_vm(vm_name)
response = dict()
deploy_vm_task = vm.deploy()
self.execute_task(deploy_vm_task)
response['msg'] = 'Vapp VM {} has been deployed.'.format(vm_name)
response['changed'] = True
return response
def undeploy_vm(self, vm_name):
vm = self.get_vm(vm_name)
response = dict()
undeploy_vm_task = vm.undeploy()
self.execute_task(undeploy_vm_task)
response['msg'] = 'Vapp VM {} has been undeployed.'.format(vm_name)
response['changed'] = True
return response
def create_from_catalog(self, request):
logging.info("__INIT__create[VappVm] source_catalog_name[%s]",
request.source_catalog_name)
res = vapp_vm_pb2.CreateVappVmResult()
res.created = False
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
try:
vdc_resource = org.get_vdc(request.target_vdc)
vdc = VDC(self.client, name=request.target_vdc,
resource=vdc_resource)
vapp_resource = vdc.get_vapp(request.target_vapp)
vapp = VApp(self.client, name=request.target_vapp,
resource=vapp_resource)
catalog_item = org.get_catalog_item(request.source_catalog_name,
request.source_template_name)
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
specs = [{
'source_vm_name': request.source_vm_name,
'vapp': source_vapp_resource,
'target_vm_name': request.target_vm_name,
'hostname': request.hostname,
'network': request.network,
'ip_allocation_mode': request.ip_allocation_mode,
# 'storage_profile': request.storage_profile
}]
create_vapp_vm_resp = vapp.add_vms(specs,
power_on=request.power_on,
all_eulas_accepted=request.all_eulas_accepted)
task_monitor = self.client.get_task_monitor()
task = task_monitor.wait_for_status(
task=create_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st != TaskStatus.SUCCESS.value:
raise errors.VappVmCreateError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
res.created = True
except Exception as e:
errmsg = '''__ERROR_create[VappVm] failed for vm {0}. __ErrorMessage__ {1}'''
logging.warn(errmsg.format(request.target_vm_name, str(e)))
self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
self.context.set_details(errmsg)
return res
logging.info("__DONE__create[VappVm]")
return res
