def _get_vms(self, host):
"""Get vms."""
# loop through vms on host
for vm_obj in host.vm:
vm_name = vm_obj.config.name.lower()
vm_ip = vm_obj.guest.ipAddress
logging.debug('vm name: %s, ip: %s', vm_name, vm_ip)
self.inv['_meta']['hostvars'].setdefault(vm_name, dict())
if vm_ip:
self.inv['_meta']['hostvars'][vm_name]['ansible_host'] = vm_ip
if self.module.params.get('properties'):
if not self._get_vm_properties(vm_obj):
self.inv['_meta']['hostvars'].pop(vm_name)
continue
self._get_customvalues(vm_obj)
if self.module.params.get('gather_vm_facts'):
facts = vmware.gather_vm_facts(self.content, vm_obj)
# BUG: creation_time is not json serializable
# issue is with vmware.gather_vm_facts
# remove snapshot information from facts to bypass error
facts.pop('snapshots', None)
facts.pop('current_snapshot', None)
self.inv['_meta']['hostvars'][vm_name] = facts
logging.debug('vm facts: %s', json.dumps(facts, indent=4))
def set_vnc_extraconfig(content, vm, enabled, ip, port, password):
result = dict(
changed=False,
failed=False,
)
# set new values
key_prefix = "remotedisplay.vnc."
new_values = dict()
for key in ['enabled', 'ip', 'port', 'password']:
new_values[key_prefix + key] = ""
if enabled:
new_values[key_prefix + "enabled"] = "true"
new_values[key_prefix + "password"] = str(password).strip()
new_values[key_prefix + "ip"] = str(ip).strip()
new_values[key_prefix + "port"] = str(port).strip()
# get current vnc config
current_values = get_vnc_extraconfig(vm)
# check if any value is changed
reconfig_vm = False
for key, val in new_values.items():
key = key.replace(key_prefix, "")
current_value = current_values.get(key, "")
# enabled is not case-sensitive
if key == "enabled":
current_value = current_value.lower()
val = val.lower()
if current_value != val:
reconfig_vm = True
if not reconfig_vm:
return result
# reconfigure vm
spec = vim.vm.ConfigSpec()
spec.extraConfig = []
for key, val in new_values.items():
opt = vim.option.OptionValue()
opt.key = key
opt.value = val
spec.extraConfig.append(opt)
task = vm.ReconfigVM_Task(spec)
try:
wait_for_task(task)
except TaskError as task_err:
result['failed'] = True
result['msg'] = to_native(task_err)
if task.info.state == 'error':
result['failed'] = True
result['msg'] = task.info.error.msg
else:
result['changed'] = True
result['instance'] = gather_vm_facts(content, vm)
return result
def power_on(self):
facts = {}
if self.params['power_on']:
task = self.entity.PowerOn()
if self.params['wait']:
wait_for_task(task)
if self.params['wait_for_ip_address']:
_facts = wait_for_vm_ip(self.si, self.entity)
if not _facts:
self.module.fail_json(msg='Waiting for IP address timed out')
facts.update(_facts)
if not facts:
facts.update(gather_vm_facts(self.si, self.entity))
return facts
def get_new_vm_info(self, vm):
# to check if vm has been cloned in the destination vc
# query for the vm in destination vc
# get the host and datastore info
# get the power status of the newly cloned vm
info = {}
vm_obj = find_vm_by_name(content=self.destination_content, vm_name=vm)
if vm_obj is None:
self.module.fail_json(msg="Newly cloned VM is not found in the destination VCenter")
else:
vm_facts = gather_vm_facts(self.destination_content, vm_obj)
info['vm_name'] = vm
info['vcenter'] = self.destination_vcenter
info['host'] = vm_facts['hw_esxi_host']
info['datastore'] = vm_facts['hw_datastores']
info['vm_folder'] = vm_facts['hw_folder']
info['power_on'] = vm_facts['hw_power_status']
return info
def gather_facts(self, vm):
return gather_vm_facts(self.content, vm)
def get_lease(self):
datastore, datacenter, resource_pool, network_mappings = self.get_objects()
params = {
'diskProvisioning': self.params['disk_provisioning'],
}
if self.params['name']:
params['entityName'] = self.params['name']
if network_mappings:
params['networkMapping'] = network_mappings
if self.params['deployment_option']:
params['deploymentOption'] = self.params['deployment_option']
if self.params['properties']:
params['propertyMapping'] = []
for key, value in self.params['properties'].items():
property_mapping = vim.KeyValue()
property_mapping.key = key
property_mapping.value = value
params['propertyMapping'].append(property_mapping)
if self.params['folder']:
folder = self.si.searchIndex.FindByInventoryPath(self.params['folder'])
else:
folder = datacenter.vmFolder
spec_params = vim.OvfManager.CreateImportSpecParams(**params)
ovf_descriptor = self.get_ovf_descriptor()
self.import_spec = self.si.ovfManager.CreateImportSpec(
ovf_descriptor,
resource_pool,
datastore,
spec_params
)
errors = [to_native(e.msg) for e in getattr(self.import_spec, 'error', [])]
if self.params['fail_on_spec_warnings']:
errors.extend(
(to_native(w.msg) for w in getattr(self.import_spec, 'warning', []))
)
if errors:
self.module.fail_json(
msg='Failure validating OVF import spec: %s' % '. '.join(errors)
)
for warning in getattr(self.import_spec, 'warning', []):
self.module.warn('Problem validating OVF import spec: %s' % to_native(warning.msg))
if not self.params['allow_duplicates']:
name = self.import_spec.importSpec.configSpec.name
match = find_vm_by_name(self.si, name, folder=folder)
if match:
self.module.exit_json(instance=gather_vm_facts(self.si, match), changed=False)
if self.module.check_mode:
self.module.exit_json(changed=True, instance={'hw_name': name})
try:
self.lease = resource_pool.ImportVApp(
self.import_spec.importSpec,
folder
)
except vmodl.fault.SystemError as e:
self.module.fail_json(
msg='Failed to start import: %s' % to_native(e.msg)
)
while self.lease.state != vim.HttpNfcLease.State.ready:
time.sleep(0.1)
self.entity = self.lease.info.entity
return self.lease, self.import_spec
class VMwareDeployOvf:
def __init__(self, module):
self.si = connect_to_api(module)
self.module = module
self.params = module.params
self.datastore = None
self.datacenter = None
self.resource_pool = None
self.network_mappings = []
self.property_mappings = []
self.ovf_descriptor = None
self.tar = None
self.lease = None
self.import_spec = None
self.entity = None
def get_vm_obj(self):
self.vm = find_vm_by_name(self.si, self.params['name'])
return self.vm
def get_objects(self):
self.datastore = find_datastore_by_name(self.si,
self.params['datastore'])
if not self.datastore:
self.module.fail_json(msg='%(datastore)s could not be located' %
self.params)
self.datacenter = find_datacenter_by_name(self.si,
self.params['datacenter'])
if not self.datacenter:
self.module.fail_json(msg='%(datacenter)s could not be located' %
self.params)
# self.vm = find_vm_by_name(self.si, self.params['name'])
# if not self.vm:
# self.module.fail_json(msg='%(name)s could not be located' % self.params)
self.resource_pool = find_resource_pool_by_name(
self.si, self.params['resource_pool'])
if not self.resource_pool:
self.module.fail_json(
msg='%(resource_pool)s could not be located' % self.params)
for key, value in self.params['ovf_networks'].items():
network = find_network_by_name(self.si, value)
if not network:
self.module.fail_json(
msg='%(ovf_network)s could not be located' % self.params)
network_mapping = vim.OvfManager.NetworkMapping()
network_mapping.name = key
network_mapping.network = network
self.network_mappings.append(network_mapping)
if self.params['property_map']:
for key, value in self.params['property_map'].items():
property_map = vim.KeyValue()
property_map.key = key
property_map.value = value
self.property_mappings.append(property_map)
return self.datastore, self.datacenter, self.resource_pool, self.network_mappings, self.property_mappings
#return self.datastore, self.datacenter, self.vm, self.resource_pool, self.network_mappings
#return self.datastore
def get_ovf_descriptor(self):
if tarfile.is_tarfile(self.params['ovf']):
self.tar = tarfile.open(self.params['ovf'])
ovf = None
for candidate in self.tar.getmembers():
dummy, ext = os.path.splitext(candidate.name)
if ext.lower() == '.ovf':
ovf = candidate
break
if not ovf:
self.module.fail_json(
msg='Could not locate OVF file in %(ovf)s' % self.params)
self.ovf_descriptor = to_native(self.tar.extractfile(ovf).read())
else:
with open(self.params['ovf']) as f:
self.ovf_descriptor = f.read()
return self.ovf_descriptor
def get_lease(self):
datastore, datacenter, resource_pool, network_mappings, property_mappings = self.get_objects(
)
params = {
'diskProvisioning': self.params['disk_provisioning'],
}
if self.params['name']:
params['entityName'] = self.params['name']
if network_mappings:
params['networkMapping'] = network_mappings
if property_mappings:
params['propertyMapping'] = property_mappings
if self.params['deployment_option']:
params['deploymentOption'] = self.params['deployment_option']
spec_params = vim.OvfManager.CreateImportSpecParams(**params)
ovf_descriptor = self.get_ovf_descriptor()
self.import_spec = self.si.ovfManager.CreateImportSpec(
ovf_descriptor, resource_pool, datastore, spec_params)
#self.lease = resource_pool.ImportVApp(
# self.import_spec.importSpec,
# datacenter.vmFolder
#)
#joined_errors = '. '.join(to_native(e.msg) for e in getattr(self.import_spec, 'error', []))
errors = [
to_native(e.msg) for e in getattr(self.import_spec, 'error', [])
]
spec_warnings = True
if spec_warnings:
errors.extend((to_native(w.msg)
for w in getattr(self.import_spec, 'warning', [])))
if errors:
self.module.fail_json(
msg='Failure validating OVF import spec: %s' %
'. '.join(errors))
for warning in getattr(self.import_spec, 'warning', []):
self.module.warn(to_native(warning.msg))
try:
self.lease = resource_pool.ImportVApp(self.import_spec.importSpec,
datacenter.vmFolder)
except vmodl.fault.SystemError as e:
self.module.fail_json(msg='Failed to start import: %s' %
to_native(e.msg))
while self.lease.state != vim.HttpNfcLease.State.ready:
time.sleep(0.1)
self.entity = self.lease.info.entity
return self.lease, self.import_spec
def upload(self):
ovf_dir = os.path.dirname(self.params['ovf'])
lease, import_spec = self.get_lease()
uploaders = []
for file_item in import_spec.fileItem:
vmdk_post_url = None
for device_url in lease.info.deviceUrl:
if file_item.deviceId == device_url.importKey:
vmdk_post_url = device_url.url.replace(
'*', self.params['hostname'])
break
if not vmdk_post_url:
lease.HttpNfcLeaseAbort(
vmodl.fault.SystemError(
reason='Failed to find deviceUrl for file %s' %
file_item.path))
self.module.fail_json(
msg='Failed to find deviceUrl for file %s' %
file_item.path)
if self.tar:
vmdk = self.tar
try:
vmdk_tarinfo = self.tar.getmember(file_item.path)
except KeyError:
lease.HttpNfcLeaseAbort(
vmodl.fault.SystemError(
reason='Failed to find VMDK file %s in OVA' %
file_item.path))
self.module.fail_json(
msg='Failed to find VMDK file %s in OVA' %
file_item.path)
else:
vmdk = os.path.join(ovf_dir, file_item.path)
try:
path_exists(vmdk)
except ValueError:
lease.HttpNfcLeaseAbort(
vmodl.fault.SystemError(
reason='Failed to find VMDK file at %s' % vmdk))
self.module.fail_json(
msg='Failed to find VMDK file at %s' % vmdk)
vmdk_tarinfo = None
uploaders.append(
VMDKUploader(vmdk,
vmdk_post_url,
self.params['validate_certs'],
tarinfo=vmdk_tarinfo,
create=file_item.create))
total_size = sum(u.size for u in uploaders)
total_bytes_read = [0] * len(uploaders)
for i, uploader in enumerate(uploaders):
uploader.start()
while uploader.is_alive():
time.sleep(0.1)
total_bytes_read[i] = uploader.bytes_read
lease.HttpNfcLeaseProgress(
int(100.0 * sum(total_bytes_read) / total_size))
if uploader.e:
lease.HttpNfcLeaseAbort(
vmodl.fault.SystemError(reason='%s' %
to_native(uploader.e[1])))
self.module.fail_json(msg='%s' % to_native(uploader.e[1]),
exception=''.join(
traceback.format_tb(uploader.e[2])))
def complete(self):
self.lease.HttpNfcLeaseComplete()
def power_on(self):
facts = {}
if self.params['power_on']:
task = self.entity.PowerOn()
if self.params['wait']:
try:
wait_for_task(task)
except Exception, e:
self.module.fail_json(
msg="Unable to PowerOn VM due to: %s" %
to_native(e.message.msg))
if task.info.state == 'error':
self.module.exit_json(msg="Error occured: %s" %
to_native(task.info.error.msg))
if self.params['wait_for_ip_address']:
_facts = wait_for_vm_ip(self.si, self.entity)
if not _facts:
self.module.fail_json(
msg='Waiting for IP address timed out')
facts.update(_facts)
if not facts:
gather_vm_facts(self.si, self.entity)
return facts
if self.params['power_on']:
task = vm_obj.PowerOn()
if self.params['wait']:
wait_for_task(task)
if self.params['wait_for_ip_address']:
_facts = wait_for_vm_ip(self.si, vm_obj)
if not _facts:
self.module.fail_json(
msg='Waiting for IP address timed out')
facts.update(_facts)
except Exception, e:
self.module.fail_json(msg="Error received from vCenter:%s" %
(e.message.msg))
if not facts:
gather_vm_facts(self.si, vm_obj)
return facts
def custom_wait_for_task(task, module):
try:
wait_for_task(task)
except Exception, e:
module.fail_json(msg="Error received from vCenter" % e.message.msg)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
disk_provisioning=dict(type='str',
def gather_facts(self, vm):
return gather_vm_facts(self.content, vm)
