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)